ओपनजीएल जानें। पाठ 5.9 - विलंबित प्रतिपादन

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

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

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

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

नीचे दी गई छवि सामान्य ड्राइंग प्रक्रिया को अच्छी तरह से दिखाती है।

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

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

(नोट लेन। - जी-बफर बहुत मेमोरी स्पेस लेता है। उदाहरण के लिए, 1920 * 1080 की स्क्रीन के लिए और पिक्सेल प्रति 128 बिट्स का उपयोग करते हुए, बफर 33mb ले जाएगा। मेमोरी बैंडविड्थ के लिए बढ़ती आवश्यकताएं हैं - बहुत अधिक डेटा लिखा और पढ़ा जा रहा है)

जी बफर

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

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

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

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

छद्म कोड में, सामान्य चित्र कुछ इस तरह दिखता है:

while(...) // render loop { // 1.  :  /    g- glBindFramebuffer(GL_FRAMEBUFFER, gBuffer); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); gBufferShader.use(); for(Object obj : Objects) { ConfigureShaderTransformsAndUniforms(); obj.Draw(); } // 2.  :  g-     glBindFramebuffer(GL_FRAMEBUFFER, 0); glClear(GL_COLOR_BUFFER_BIT); lightingPassShader.use(); BindAllGBufferTextures(); SetLightingUniforms(); RenderQuad(); } 

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

ज्यामितीय पास के लिए, स्पष्ट नाम gBuffer के साथ एक फ्रेमबफ़र बनाएं, जिसमें हम कई रंग बफर और एक गहराई बफर संलग्न करेंगे। पदों और मानदंडों को संग्रहीत करने के लिए, उच्च सटीकता (प्रत्येक घटक के लिए 16 या 32-बिट फ्लोट मान) के साथ एक बनावट का उपयोग करना बेहतर होता है, हम बनावट में फैलाना रंग और स्पेक्युलर मान डिफ़ॉल्ट रूप से (8 बिट प्रति घटक सटीकता) संग्रहीत करेंगे।

 unsigned int gBuffer; glGenFramebuffers(1, &gBuffer); glBindFramebuffer(GL_FRAMEBUFFER, gBuffer); unsigned int gPosition, gNormal, gColorSpec; //   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); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gPosition, 0); //   glGenTextures(1, &gNormal); glBindTexture(GL_TEXTURE_2D, gNormal); 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); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, gNormal, 0); //    +    glGenTextures(1, &gAlbedoSpec); glBindTexture(GL_TEXTURE_2D, gAlbedoSpec); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, SCR_WIDTH, SCR_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, 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_ATTACHMENT2, GL_TEXTURE_2D, gAlbedoSpec, 0); //  OpenGL,        unsigned int attachments[3] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2 }; glDrawBuffers(3, attachments); //           . [...] 

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

भविष्य में, हमें डेटा को जी-बफर को प्रस्तुत करना होगा। यदि प्रत्येक वस्तु में रंग, सामान्य और स्पेक्युलर परावर्तन गुणांक है, तो हम निम्नलिखित शेडर की तरह कुछ लिख सकते हैं:

 #version 330 core layout (location = 0) out vec3 gPosition; layout (location = 1) out vec3 gNormal; layout (location = 2) out vec4 gAlbedoSpec; in vec2 TexCoords; in vec3 FragPos; in vec3 Normal; uniform sampler2D texture_diffuse1; uniform sampler2D texture_specular1; void main() { //       G- gPosition = FragPos; //          G- gNormal = normalize(Normal); //   gAlbedoSpec.rgb = texture(texture_diffuse1, TexCoords).rgb; //       gAlbedoSpec.a = texture(texture_specular1, TexCoords).r; } 

चूंकि हम कई प्रतिपादन लक्ष्यों का उपयोग करते हैं, layout की मदद से layout यह संकेत layout हैं कि वर्तमान फ्रेमबफ़र के बफर में layout क्या और क्या प्रस्तुत करते हैं। कृपया ध्यान दें कि हम अलग-अलग बफर में दर्पण गुणांक को स्टोर नहीं करते हैं, क्योंकि हम बफ़र में से किसी एक के अल्फा चैनल में फ्लोट मूल्य को स्टोर कर सकते हैं।

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

अगर अब हम कई नैनो-जीट्स को जी-बफर में प्रस्तुत करते हैं और स्क्रीन के एक चौथाई हिस्से पर प्रत्येक बफर को प्रोजेक्ट करके इसकी सामग्री बनाते हैं, तो हम कुछ इस तरह देखेंगे:

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

प्रकाश मार्ग

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

प्रकाश के पारित होने के लिए, हम एक पूर्ण-स्क्रीन आयत (थोड़ा बाद के प्रसंस्करण प्रभाव) को प्रस्तुत करने जा रहे हैं और प्रत्येक पिक्सेल के लिए प्रकाश की धीमी गणना करते हैं।

 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_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, gAlbedoSpec); //         shaderLightingPass.use(); SendAllLightUniformsToShader(shaderLightingPass); shaderLightingPass.setVec3("viewPos", camera.Position); RenderQuad(); 

हम प्रतिपादन से पहले सभी आवश्यक जी-बफर बनावट को बांधते हैं , और इसके अलावा, शेडर में प्रकाश-संबंधित चर मान सेट करते हैं।

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

 #version 330 core out vec4 FragColor; in vec2 TexCoords; uniform sampler2D gPosition; uniform sampler2D gNormal; uniform sampler2D gAlbedoSpec; struct Light { vec3 Position; vec3 Color; }; const int NR_LIGHTS = 32; uniform Light lights[NR_LIGHTS]; uniform vec3 viewPos; void main() { //    G- vec3 FragPos = texture(gPosition, TexCoords).rgb; vec3 Normal = texture(gNormal, TexCoords).rgb; vec3 Albedo = texture(gAlbedoSpec, TexCoords).rgb; float Specular = texture(gAlbedoSpec, TexCoords).a; //     vec3 lighting = Albedo * 0.1; //    vec3 viewDir = normalize(viewPos - FragPos); for(int i = 0; i < NR_LIGHTS; ++i) { //   vec3 lightDir = normalize(lights[i].Position - FragPos); vec3 diffuse = max(dot(Normal, lightDir), 0.0) * Albedo * lights[i].Color; lighting += diffuse; } FragColor = vec4(lighting, 1.0); } 

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

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

32 छोटे प्रकाश स्रोतों के साथ एक सरल डेमो शुरू करना कुछ इस तरह है:

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

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

प्रत्यक्ष के साथ आस्थगित प्रतिपादन मिलाएं।

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

 //    [...] RenderQuad(); //          shaderLightBox.use(); shaderLightBox.setMat4("projection", projection); shaderLightBox.setMat4("view", view); for (unsigned int i = 0; i < lightPositions.size(); i++) { model = glm::mat4(); model = glm::translate(model, lightPositions[i]); model = glm::scale(model, glm::vec3(0.25f)); shaderLightBox.setMat4("model", model); shaderLightBox.setVec3("lightColor", lightColors[i]); RenderCube(); } 

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

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

हम glBlitFramebuffer फ़ंक्शन का उपयोग करके glBlitFramebuffer की सामग्री को दूसरे glBlitFramebuffer कॉपी कर सकते हैं। हमने इस फ़ंक्शन का उपयोग एंटी-अलियासिंग उदाहरण: ( एंटी-एलियासिंग ), अनुवाद में किया है । glBlitFramebuffer फ़ंक्शन glBlitFramebuffer के उपयोगकर्ता-निर्दिष्ट भाग को किसी अन्य glBlitFramebuffer निर्दिष्ट भाग की प्रतिलिपि बनाता है।

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

 glBindFramebuffer(GL_READ_FRAMEBUFFER, gBuffer); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); //   - glBlitFramebuffer( 0, 0, SCR_WIDTH, SCR_HEIGHT, 0, 0, SCR_WIDTH, SCR_HEIGHT, GL_DEPTH_BUFFER_BIT, GL_NEAREST ); glBindFramebuffer(GL_FRAMEBUFFER, 0); //        [...] 

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

डेमो का स्रोत कोड यहां पाया जा सकता है ।

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

अधिक प्रकाश स्रोत

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

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

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

इस दृष्टिकोण के साथ, प्रकाश स्रोत की कार्रवाई के क्षेत्र का आकार निर्धारित करने के लिए मुख्य चाल है।

एक प्रकाश स्रोत (त्रिज्या) के दायरे की गणना

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

$$

$$F_ {प्रकाश} = \ frac {I} {K_c + K_l * d + K_q * d 2}$$

हम इस समीकरण को उस स्थिति के लिए हल करना चाहते हैं जब $$$F_ {प्रकाश} = 0.0$ , यानी, जब प्रकाश स्रोत पूरी तरह से अंधेरा है। हालांकि, यह समीकरण कभी भी 0.0 के सटीक मूल्य तक नहीं पहुंचेगा, इसलिए इसका कोई हल नहीं है। हालांकि, हम इसके बजाय 0.0 के करीब मूल्य के लिए चमक के लिए समीकरण को हल कर सकते हैं, जिसे व्यावहारिक रूप से अंधेरा माना जा सकता है। इस उदाहरण में, हम स्वीकार्य चमक मूल्य पर विचार करते हैं $$$\ frac {5} {256}$ - 256 से विभाजित, 8-बिट फ्रेमबफ़र में 256 अलग चमक मान हो सकते हैं।

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

क्षीणन समीकरण जिसे हमें हल करना चाहिए वह बन जाता है:

$$

$$\ frac {5} {256} = \ frac {I_ {max}} {Attenuation}$$

यहां $$$I_ {अधिकतम}$ - प्रकाश का सबसे चमकदार घटक (आर, जी, बी चैनलों से)। हम सबसे उज्ज्वल घटक का उपयोग करेंगे, क्योंकि अन्य घटक प्रकाश स्रोत के दायरे पर एक कमजोर प्रतिबंध देंगे।

हम समीकरण हल करना जारी रखते हैं:

$$

$$\ frac {5} {256} \ cdot Attenuation = I_ {max}$$

$$

$$Attenuation = I_ {max} \ cdot \ frac {256} {5}$$

$$

$$K_c + K_l \ cdot d + K_q \ cdot d ^ 2 = I_ {max} \ cdot \ frac {256} {5}$$

$$

$$K_c + K_l \ cdot d + K_q \ cdot d ^ 2 - I_ {अधिकतम} \ cdot \ frac {256} {5} = 0$$

अंतिम समीकरण फॉर्म में एक द्विघात समीकरण है $$$x ^ 2 + b x + c = 0$ निम्नलिखित समाधान के साथ:

$$

$$x = \ frac {-K_l + \ sqrt {K_l ^ 2 - 4 K_q (K_c - I_max \ frac {256} {5})}} {2 K_q}$$

हमें एक सामान्य समीकरण मिला जो हमें प्रकाश स्रोत के त्रिज्या - x को खोजने के लिए मापदंडों (निरंतर क्षीणन, रैखिक और द्विघात गुणांक) को बदलने की अनुमति देता है।

 float constant = 1.0; float linear = 0.7; float quadratic = 1.8; float lightMax = std::fmaxf(std::fmaxf(lightColor.r, lightColor.g), lightColor.b); float radius = (-linear + std::sqrtf(linear * linear - 4 * quadratic * (constant - (256.0 / 5.0) * lightMax))) / (2 * quadratic); 

सूत्र प्रकाश स्रोत की अधिकतम चमक के आधार पर लगभग 1.0 और 5.0 के बीच एक त्रिज्या देता है।

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

 struct Light { [...] float Radius; }; void main() { [...] for(int i = 0; i < NR_LIGHTS; ++i) { //         float distance = length(lights[i].Position - FragPos); if(distance < lights[i].Radius) { //     [...] } } } 

परिणाम पहले की तरह ही है, लेकिन अब प्रत्येक प्रकाश स्रोत के लिए इसके प्रभाव को इसकी कार्रवाई के क्षेत्र के भीतर ही ध्यान में रखा जाता है।

अंतिम कोड एक डेमो है। ।

प्रकाश स्रोत के दायरे का वास्तविक अनुप्रयोग।

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

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

, . , , . _*__
_ + __ , .

: ( ) , , , - ( ). stenil .

, , , . ( ) : c (deferred lighting) (tile-based deferred shading) . MSAA. .

vs

( ) - , , . , — , MSAA, .

( ), ( g- ..) . , .

: , , , . , , , . . parallax mapping, , . , .

• Tutorial 35: Deferred Shading — Part 1 — OGLDev . .
• Deferred Rendering for Current and Future Rendering Pipelines : c Andrew Lauritzen (tile-based deferred shading) c (deferred lighting) .

PS - . , !