ओपनजीएल जानें। पाठ 5.6 - लंबन मानचित्रण

लंबन मानचित्रण

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


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


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


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

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

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

मुख्य कठिनाई यह है कि एक बिंदु के बनावट निर्देशांक की गणना कैसे करें $$$\ color {नीला} B$ बिंदु पर है $$$\ रंग {हरा} एक$ । लंबन मैपिंग सतह से दिशा वेक्टर की सरल स्केलिंग का उपयोग करके एक अनुमानित समाधान प्रदान करता है $$$\ रंग {नारंगी} {\ बार {V}}$ टुकड़े के लिए ऊंचाई द्वारा पर्यवेक्षक को $$$\ रंग {हरा} एक$ । यानी बस लंबाई बदलें $$$\ रंग {नारंगी} {\ बार {V}}$ इतना है कि यह ऊंचाई के नक्शे से नमूना आकार से मेल खाता है $$$\ रंग {हरा} {एच (ए)}$ टुकड़े के समान $$$\ रंग {हरा} एक$ । नीचे दिया गया आरेख स्केलिंग - वेक्टर के परिणाम को दर्शाता है $$$\ रंग {भूरा} {\ बार {पी}}$ :


अगला, परिणामी वेक्टर $$$\ रंग {भूरा} {\ बार {पी}}$ विमान के समन्वय प्रणाली के अनुसार घटकों में विघटित, जो मूल बनावट निर्देशांक के लिए ऑफसेट के रूप में उपयोग किया जाता है। इसके अलावा, वेक्टर के बाद से $$$\ रंग {भूरा} {\ बार {पी}}$ ऊँचाई के नक्शे से मूल्य का उपयोग करके गणना की जाती है, ऊँचाई मान वर्तमान टुकड़े से मेल खाती है, इसके लिए ऑफसेट जितना मजबूत होगा।

यह सरल तकनीक कुछ मामलों में अच्छे परिणाम देती है, लेकिन यह अभी भी एक बिंदु की स्थिति का बहुत मोटा अनुमान है $$$\ color {नीला} B$ । यदि ऊंचाई के नक्शे में तेजी से बदलते मूल्यों वाले क्षेत्र हैं, तो विस्थापन का परिणाम गलत हो जाता है: सबसे अधिक संभावना वेक्टर $$$\ रंग {भूरा} {\ बार {पी}}$ यहां तक ​​कि करीब बिंदु के आसपास में नहीं गिर जाएगा $$$\ color {नीला} B$ :

उपरोक्त के आधार पर, एक और सवाल बना हुआ है: वेक्टर को सही ढंग से कैसे निर्धारित किया जाए, यह निर्धारित करने के लिए $$$\ रंग {भूरा} {\ बार {पी}}$ बनावट निर्देशांक को ऑफसेट करने के लिए घटकों को प्राप्त करने के लिए एक मनमाने ढंग से उन्मुख सतह? एक निश्चित समन्वय प्रणाली में गणना करना अच्छा होगा, जहां वेक्टर का विस्तार होगा $$$\ रंग {भूरा} {\ बार {पी}}$ घटकों पर x और y हमेशा बनावट समन्वय प्रणाली के आधार के अनुरूप होंगे। यदि आपने ध्यान से नॉर्मल मैपिंग पर पाठ किया है, तो आपने पहले ही अनुमान लगा लिया था कि हम स्पर्शरेखा स्थान में गणना के बारे में बात कर रहे हैं।

वेक्टर को सतह से पर्यवेक्षक तक स्थानांतरित करना $$$\ रंग {नारंगी} {\ बार {V}}$ स्पर्शरेखा स्थान में हमें एक संशोधित वेक्टर मिलता है $$$\ रंग {भूरा} {\ बार {पी}}$ , जिसका घटक विघटन हमेशा एक दी गई सतह के लिए स्पर्शरेखा और द्वि-स्पर्शरेखा वैक्टर के अनुसार किया जाएगा। चूंकि स्पर्शरेखा और द्वि-स्पर्शरेखा हमेशा सतह की बनावट समन्वय प्रणाली के अक्षों के साथ गठबंधन की जाती है, फिर, सतह के उन्मुखीकरण की परवाह किए बिना, आप वेक्टर के x और y घटकों का सुरक्षित रूप से उपयोग कर सकते हैं। $$$\ रंग {भूरा} {\ बार {पी}}$ बनावट के लिए ऑफसेट के रूप में निर्देशांक।

हालांकि, सिद्धांत पर्याप्त है और, हमारी आस्तीन को लुढ़का हुआ है, हम तत्काल कार्यान्वयन की ओर मुड़ते हैं।

लंबन मानचित्रण

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

आपने शायद पहले से ही ध्यान दिया है कि ऊपर दिए गए लिंक में दिखाया गया विस्थापन मानचित्र, वास्तव में, पाठ की शुरुआत में दिखाए गए मानचित्र का व्युत्क्रम है। लंबन मैपिंग का कार्यान्वयन आमतौर पर ऐसे मानचित्रों का उपयोग करके किया जाता है, जो ऊंचाई के नक्शे - गहराई के नक्शे के विपरीत होते हैं। ऐसा इसलिए होता है क्योंकि समतल पर नकल की तुलना में ऊंचाई की नकल कुछ आसान होती है। इस परिवर्तन के अनुसार, लंबन मैपिंग कार्य योजना में भी परिवर्तन होता है:


फिर से हम परिचित डॉट्स देखते हैं $$$\ रंग {हरा} एक$ और $$$\ color {नीला} B$ हालाँकि, इस बार वेक्टर $$$\ रंग {भूरा} {\ बार {पी}}$ वेक्टर को घटाकर प्राप्त किया गया $$$\ रंग {नारंगी} {\ बार {V}}$ बनावट से एक बिंदु पर निर्देशांक होता है $$$\ रंग {हरा} एक$ । ऊंचाइयों के बजाय गहराई को एकता से गहराई के नमूने को घटाकर या किसी भी छवि संपादक में बनावट के रंगों को सम्मिलित करके प्राप्त किया जा सकता है।

लंबन मैपिंग को टुकड़े टुकड़े करने वाले में लागू किया जाता है, क्योंकि त्रिकोण के अंदर प्रत्येक टुकड़े के लिए ऊंचाई डेटा भिन्न होता है। टुकड़ा shader कोड को टुकड़ा से पर्यवेक्षक को वेक्टर की गणना की आवश्यकता होगी $$$\ रंग {नारंगी} {\ बार {V}}$ , इसलिए यह उसके लिए आवश्यक होगा कि वह मूर्त स्थान और पर्यवेक्षक की स्थिति को स्पर्शरेखा में बताए। नॉर्मल मैपिंग के बारे में पाठ के परिणामों के अनुसार, हमारे हाथों में अभी भी वर्टीकल शेडर है, जो इन सभी वैक्टरों को पहले से ही कम हो चुके स्पर्शरेखा स्थान पर स्थानांतरित करता है, हम इसका उपयोग करेंगे:

#version 330 core layout (location = 0) in vec3 aPos; layout (location = 1) in vec3 aNormal; layout (location = 2) in vec2 aTexCoords; layout (location = 3) in vec3 aTangent; layout (location = 4) in vec3 aBitangent; out VS_OUT { vec3 FragPos; vec2 TexCoords; vec3 TangentLightPos; vec3 TangentViewPos; vec3 TangentFragPos; } vs_out; uniform mat4 projection; uniform mat4 view; uniform mat4 model; uniform vec3 lightPos; uniform vec3 viewPos; void main() { gl_Position = projection * view * model * vec4(aPos, 1.0); vs_out.FragPos = vec3(model * vec4(aPos, 1.0)); vs_out.TexCoords = aTexCoords; vec3 T = normalize(mat3(model) * aTangent); vec3 B = normalize(mat3(model) * aBitangent); vec3 N = normalize(mat3(model) * aNormal); mat3 TBN = transpose(mat3(T, B, N)); vs_out.TangentLightPos = TBN * lightPos; vs_out.TangentViewPos = TBN * viewPos; vs_out.TangentFragPos = TBN * vs_out.FragPos; } 

महत्वपूर्ण चीजों में से, मैं केवल यह ध्यान देता हूं कि विशेष रूप से लंबन मैपिंग की जरूरतों के लिए, यह आवश्यक है कि aPos और व्यूपॉस पर्यवेक्षक की स्थिति को अंश shader में स्थानांतरित किया जाए ।

शेडर के अंदर, हम लंबन मैपिंग एल्गोरिथ्म को लागू करते हैं, जो कुछ इस तरह दिखता है:

 #version 330 core out vec4 FragColor; in VS_OUT { vec3 FragPos; vec2 TexCoords; vec3 TangentLightPos; vec3 TangentViewPos; vec3 TangentFragPos; } fs_in; uniform sampler2D diffuseMap; uniform sampler2D normalMap; uniform sampler2D depthMap; uniform float height_scale; vec2 ParallaxMapping(vec2 texCoords, vec3 viewDir); void main() { vec3 viewDir = normalize(fs_in.TangentViewPos - fs_in.TangentFragPos); //       Parallax Mapping vec2 texCoords = ParallaxMapping(fs_in.TexCoords, viewDir); //      //     vec3 diffuse = texture(diffuseMap, texCoords); vec3 normal = texture(normalMap, texCoords); normal = normalize(normal * 2.0 - 1.0); //  –     [...] } 

हमने लंबन मैपिंग फ़ंक्शन की घोषणा की, जो टुकड़े से बनावट और वेक्टर के टुकड़े से पर्यवेक्षक तक ले जाता है $$$\ रंग {नारंगी} {\ बार {V}}$ स्पर्शरेखा स्थान में। फ़ंक्शन का परिणाम ऑफसेट बनावट निर्देशांक है, जो पहले से ही एक फैलाना बनावट और सामान्य नक्शे से नमूनों के लिए उपयोग किया जाता है। नतीजतन, पिक्सेल का फैलाना रंग और इसका सामान्य रूप से विमान के बदले हुए "ज्यामिति" के अनुरूप है।

ParallaxMapping फ़ंक्शन के अंदर क्या छिपा है?

  vec2 ParallaxMapping(vec2 texCoords, vec3 viewDir) { float height = texture(depthMap, texCoords).r; vec2 p = viewDir.xy / viewDir.z * (height * height_scale); return texCoords - p; } 

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

हम viewDir.xy को divDir.z में विभाजित करने के क्षण से निपटेंगे । चूँकि वेक्टर दृश्य को सामान्यीकृत किया जाता है, इसका घटक z अंतराल [0, 1] में निहित है। जब वेक्टर घटक z की सतह के लगभग समानांतर होता है, शून्य के करीब होता है, और विभाजन ऑपरेशन वेक्टर को वापस कर देता है $$$\ रंग {भूरा} {\ बार {पी}}$ अगर व्यूअर सतह के लंबवत के करीब है तो उससे अधिक लंबा। दूसरे शब्दों में, हम वेक्टर को मापते हैं $$$\ रंग {भूरा} {\ बार {पी}}$ जब आप एक कोण पर सतह को देखते हैं तो यह बढ़ जाता है - यह आपको ऐसे मामलों में अधिक यथार्थवादी परिणाम प्राप्त करने की अनुमति देता है।

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

परिणामस्वरूप परिवर्तित बनावट निर्देशांक अंततः फैल मानचित्र और सामान्य मानचित्र से चयन करने के लिए उपयोग किया जाता है, जो हमें एक बहुत अच्छी सतह विरूपण प्रभाव देता है (यहां ऊंचाई_काले पैरामीटर को 0.1 के करीब चुना गया था):


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

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

 texCoords = ParallaxMapping(fs_in.TexCoords, viewDir); if(texCoords.x > 1.0 || texCoords.y > 1.0 || texCoords.x < 0.0 || texCoords.y < 0.0) discard; 

नतीजतन, स्थानांतरित बनावट के साथ सभी टुकड़े अंतराल से बाहर गिरते हैं [0, 1] को त्याग दिया जाएगा और नेत्रहीन लंबन मैपिंग कार्रवाई का परिणाम स्वीकार्य हो जाएगा। जाहिर है, यह अस्वीकृति विधि सार्वभौमिक नहीं है और कुछ सतहों या बनावट मामलों पर लागू नहीं हो सकती है। लेकिन एक विमान के उदाहरण पर, यह पूरी तरह से काम करता है और विमान की राहत को बदलने के प्रभाव को मजबूत करने में मदद करता है:


नमूना स्रोत यहां हैं ।

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


भ्रम के विनाश का कारण इस तथ्य में निहित है कि एल्गोरिथ्म वास्तविक विस्थापन मानचित्रण का एक बहुत मोटा अनुमान है। हालांकि, कई अतिरिक्त चालें हमारी मदद कर सकती हैं, जो हमें कोण को देखते हुए या तेज बदलाव के साथ ऊंचाई के नक्शे का उपयोग करते समय भी लगभग पूर्ण परिणाम प्राप्त करने की अनुमति देती हैं। उदाहरण के लिए, हम बिंदु से निकटतम बिंदु खोजने के लिए ऊंचाई के नक्शे से कई नमूनों का उपयोग कर सकते हैं $$$\ color {नीला} B$ ।

खड़ी लंबन मानचित्रण

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

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


जैसा कि आप देख सकते हैं, हम परतों के माध्यम से ऊपर से नीचे की ओर बढ़ते हैं और प्रत्येक परत के लिए हम इसकी गहराई की गहराई से मूल्य की तुलना करते हैं। यदि परत की गहराई गहराई के नक्शे से मूल्य से कम है, तो इसका मतलब है कि वेक्टर $$$\ रंग {भूरा} {\ बार {पी}}$ इस परत की सतह के ऊपर स्थित है। यह प्रक्रिया तब तक दोहराई जाती है जब तक परत की गहराई गहराई के नक्शे से चयन से अधिक नहीं हो जाती है: इस समय, वेक्टर $$$\ रंग {भूरा} {\ बार {पी}}$ नकली सतह स्थलाकृति के नीचे एक बिंदु की ओर इशारा करता है।
उदाहरण से पता चलता है कि दूसरी परत पर गहराई के नक्शे से चयन ( $$$D (2) = 0.73$ ) अब भी 0.4 के बराबर दूसरी परत की गहराई के संबंध में "गहरा" है, जिसका अर्थ है कि खोज प्रक्रिया जारी है। अगले पास में, ०. of की परत गहराई अंत में गहराई मानचित्र से नमूने का मूल्य "ऊपर" हो जाता है ( $$$D (3) = 0.37$ )। यहां से हम यह निष्कर्ष निकालते हैं कि वेक्टर $$$\ रंग {भूरा} {\ बार {पी}}$ तीसरी परत के लिए प्राप्त विकृत सतह ज्यामिति के लिए सबसे विश्वसनीय स्थिति है। आप बनावट निर्देशांक का उपयोग कर सकते हैं $$$T_3$ वेक्टर से व्युत्पन्न $$$\ रंग {भूरा} {\ बार {पी}}$ , वर्तमान टुकड़े के बनावट निर्देशांक ऑफसेट करने के लिए। जाहिर है, विधि की सटीकता परतों की संख्या के साथ बढ़ती है।

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

 vec2 ParallaxMapping(vec2 texCoords, vec3 viewDir) { //    const float numLayers = 10; //    float layerDepth = 1.0 / numLayers; //    float currentLayerDepth = 0.0; //         //     P vec2 P = viewDir.xy * height_scale; vec2 deltaTexCoords = P / numLayers; [...] } 

सबसे पहले, हम प्रारंभिक करते हैं: परतों की संख्या निर्धारित करते हैं, उनमें से प्रत्येक की गहराई की गणना करते हैं, और अंत में, वेक्टर की दिशा के साथ बनावट निर्देशांक के विस्थापन के आकार का पता लगाते हैं। $$$\ रंग {भूरा} {\ बार {पी}}$ , जिसे प्रत्येक परत पर स्थानांतरित करने की आवश्यकता होगी।

अगला परतों के माध्यम से एक मार्ग है, ऊपर से शुरू होता है, जब तक कि गहराई के नक्शे से एक चयन नहीं मिलता है जो वर्तमान परत की गहराई मूल्य "ऊपर" है:

 //   vec2 currentTexCoords = texCoords; float currentDepthMapValue = texture(depthMap, currentTexCoords).r; while(currentLayerDepth < currentDepthMapValue) { //      P currentTexCoords -= deltaTexCoords; //          currentDepthMapValue = texture(depthMap, currentTexCoords).r; //     currentLayerDepth += layerDepth; } return currentTexCoords; 

इस कोड में, हम सभी गहराई परतों को पार करते हैं और मूल बनावट निर्देशांक को शिफ्ट करते हैं जब तक कि गहराई मानचित्र से चयन वर्तमान परत की गहराई से कम न हो। ऑफसेट वेक्टर के आधार पर डेल्टा के मूल बनावट निर्देशांक से घटाकर किया जाता है $$$\ रंग {भूरा} {\ बार {पी}}$ । एल्गोरिथ्म का परिणाम बनावट निर्देशांक की ऑफसेट वेक्टर है, जिसे क्लासिक लंबन मैपिंग की तुलना में बहुत अधिक सटीकता के साथ परिभाषित किया गया है।

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


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

 const float minLayers = 8.0; const float maxLayers = 32.0; float numLayers = mix(maxLayers, minLayers, abs(dot(vec3(0.0, 0.0, 1.0), viewDir))); 

सदिश दृश्य के स्केलर उत्पाद का परिणाम और सकारात्मक अर्ध-अक्ष Z का उपयोग अंतराल में परतों की संख्या निर्धारित करने के लिए किया जाता है [ minSamples , maxSamples ], अर्थात टकटकी की दिशा प्रभाव की पुनरावृत्तियों की आवश्यक संख्या निर्धारित करती है (स्पर्श स्थान में, सकारात्मक अर्ध-अक्ष Z सतह पर सामान्य निर्देशित होता है)। यदि हम सतह के समानांतर दिखते हैं, तो प्रभाव सभी 32 परतों का उपयोग करेगा।

संशोधित स्रोत कोड यहाँ है । मैं एक लकड़ी के खिलौने की बनावट डाउनलोड करने का भी प्रस्ताव करता हूं: फैलाना , सामान्य नक्शा, गहराई का नक्शा ।

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


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

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

लंबन समावेशन मानचित्रण

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


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

लंबन आवर्धन मानचित्रण कोड, खड़ी पीएम कोड के अतिरिक्त है और बहुत जटिल नहीं है:

 [...] // ,    Steep PM //       , // ..  " " vec2 prevTexCoords = currentTexCoords + deltaTexCoords; //         //      float afterDepth = currentDepthMapValue - currentLayerDepth; float beforeDepth = texture(depthMap, prevTexCoords).r - currentLayerDepth + layerDepth; //    float weight = afterDepth / (afterDepth - beforeDepth); vec2 finalTexCoords = prevTexCoords * weight + currentTexCoords * (1.0 - weight); return finalTexCoords; 

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

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


एक उदाहरण कोड यहाँ है ।

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

अनुवादक से बोनस:

राहत लंबन मैपिंग

चूंकि लेखक ने स्टीप पीएम के परिणाम को स्पष्ट करने के लिए दो तरीकों का उल्लेख किया है, पूर्णता के लिए, मैं दृष्टिकोण के दूसरे का वर्णन करूंगा।

लंबन ऑक्यूपेशन मैपिंग की तरह, स्टीप पीएम निष्पादन का परिणाम यहां उपयोग किया जाता है, अर्थात। हम दो परतों की गहराई को जानते हैं जिनके बीच वेक्टर के प्रतिच्छेदन का वास्तविक बिंदु निहित है $$$\ रंग {नारंगी} {\ बार {V}}$ राहत के साथ-साथ संबंधित बनावट समन्वय करती है $$$T_2$ और $$$T_3$ । इस विधि में चौराहे बिंदु के अनुमान का शोधन द्विआधारी खोज के उपयोग के कारण है।

शोधन एल्गोरिथ्म कदम:

• खड़ी पीएम गणना करें और बनावट निर्देशांक प्राप्त करें $$$T_2$ और $$$T_3$ - इस अंतराल में वेक्टर का प्रतिच्छेदन बिंदु निहित है $$$\ रंग {हरा} {\ बार {V}}$ सतह स्थलाकृति के साथ। सही चौराहे को लाल क्रॉस के साथ चिह्नित किया गया है।
• बनावट के ऑफसेट और गहराई परत की ऊंचाई के लिए दो वर्तमान मूल्यों में विभाजित करें।
• चाल बनावट बिंदु से निर्देशांक $$$T_3$ वेक्टर के विपरीत दिशा में $$$\ रंग {हरा} {\ बार {V}}$ विस्थापन की मात्रा से। वर्तमान परत आकार मान द्वारा परत की गहराई कम करें।
• सीधे बाइनरी खोज। पुनरावृत्तियों की निर्दिष्ट संख्या दोहराई गई है:
• 1. गहराई के नक्शे से चयन करें। वर्तमान बनावट ऑफसेट और गहराई परत आकार को दो वर्तमान मानों में विभाजित करें।
  2. यदि नमूना आकार वर्तमान परत की गहराई से अधिक है, तो वर्तमान परत के आकार से परत की गहराई बढ़ाएं, और वेक्टर के साथ बनावट के निर्देशांक बदलें $$$\ रंग {हरा} {\ बार {V}}$ वर्तमान ऑफसेट के लिए।
  3. यदि नमूना आकार वर्तमान परत की गहराई से कम है, तो वर्तमान परत आकार द्वारा परत की गहराई को कम करें, और उलटा वेक्टर के साथ बनावट के निर्देशांक को बदलें $$$\ रंग {हरा} {\ बार {V}}$ वर्तमान ऑफसेट के लिए।
  
  
• प्राप्त किए गए अंतिम बनावट निर्देशांक पीएम राहत के परिणाम हैं।

छवि से पता चलता है कि अंक खोजने के बाद $$$T_2$ और $$$T_3$ हम परत के आकार और बनावट के ऑफसेट के आकार का समन्वय करते हैं, जो हमें बाइनरी खोज (1) का पहला पुनरावृत्ति बिंदु प्रदान करता है। चूंकि इसमें नमूना का आकार परत की वर्तमान गहराई से बड़ा हो गया है, इसलिए हम मापदंडों को फिर से आधा कर देते हैं और साथ चलते हैं $$$\ रंग {हरा} {\ बार {V}}$ बनावट निर्देशांक के साथ बिंदु (2) प्राप्त करना $$$T_p$ जो बाइनरी सर्च के दो पुनरावृत्तियों के लिए स्टेप पीएम का परिणाम होगा।

शेडर कोड:

 //  : inTexCoords -   , // inViewDir -      - //  : lastDepthValue –      //      vec2 reliefPM(vec2 inTexCoords, vec3 inViewDir, out float lastDepthValue) { // ====== // ,   Steep PM // ====== const float _minLayers = 2.; const float _maxLayers = 32.; float _numLayers = mix(_maxLayers, _minLayers, abs(dot(vec3(0., 0., 1.), inViewDir))); float deltaDepth = 1./_numLayers; // uDepthScale –     PM vec2 deltaTexcoord = uDepthScale * inViewDir.xy/(inViewDir.z * _numLayers); vec2 currentTexCoords = inTexCoords; float currentLayerDepth = 0.; float currentDepthValue = depthValue(currentTexCoords); while (currentDepthValue > currentLayerDepth) { currentLayerDepth += deltaDepth; currentTexCoords -= deltaTexcoord; currentDepthValue = depthValue(currentTexCoords); } // ====== //   Relief PM // ====== //         deltaTexcoord *= 0.5; deltaDepth *= 0.5; //      ,   Steep PM currentTexCoords += deltaTexcoord; currentLayerDepth -= deltaDepth; //    … const int _reliefSteps = 5; int currentStep = _reliefSteps; while (currentStep > 0) { currentDepthValue = depthValue(currentTexCoords); deltaTexcoord *= 0.5; deltaDepth *= 0.5; //       , //       if (currentDepthValue > currentLayerDepth) { currentTexCoords -= deltaTexcoord; currentLayerDepth += deltaDepth; } //       else { currentTexCoords += deltaTexcoord; currentLayerDepth -= deltaDepth; } currentStep--; } lastDepthValue = currentDepthValue; return currentTexCoords; } 

स्वयं छाया

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

वास्तव में, एक ही स्टेप पीएम लागू किया जाता है, लेकिन खोज गहरी रेखा के साथ दृष्टि की रेखा पर गहराई तक नहीं जाती है, लेकिन सतह से, वेक्टर स्रोत से प्रकाश स्रोत तक$$$\color{green}{\bar{L}}$ ।इस वेक्टर को स्पर्शरेखा स्थान पर भी स्थानांतरित किया जाता है और इसका उपयोग बनावट के निर्देशांक के विस्थापन की मात्रा निर्धारित करने के लिए किया जाता है। विधि के आउटपुट में, अंतराल [0, 1] में एक सामग्री रोशनी गुणांक प्राप्त किया जाता है, जिसका उपयोग प्रकाश गणना में फैलाना और दर्पण घटकों को संशोधित करने के लिए किया जाता है।
तेज किनारों के साथ छायांकन को परिभाषित करने के लिए, बस वेक्टर के साथ चलें$$ˉ L जब तक एक बिंदु सतह के नीचे स्थित है। जैसे ही ऐसा बिंदु मिलता है, हम रोशनी गुणांक 0. लेते हैं। यदि हम सतह के नीचे स्थित बिंदु से मिले बिना शून्य गहराई तक पहुँचते हैं, तो हम रोशनी के गुणांक को 1 के बराबर लेते हैं।नरम किनारों के साथ छायांकन निर्धारित करने के लिए, वेक्टर पर पड़े हुए कई बिंदुओं की जाँच करना आवश्यक है।$\color{green}{\bar{L}}$

$$ˉ L और सतह के नीचे स्थित है। छायांकन कारक को वर्तमान परत की गहराई और गहराई के नक्शे से गहराई के बीच अंतर के बराबर लिया जाता है। यह भी ध्यान में रखा (1.0 - stepIndex / numberOfSteps) केबराबर वजन गुणांक के रूप में सवाल में टुकड़े से अगले बिंदु को हटाने है। प्रत्येक चरण में, रोशनी का एक आंशिक गुणांक निर्धारित किया जाता है:$\color{green}{\bar{L}}$

$$

$$PSF_i=(layerHeight_i - heightFromtexture_i)*(1.0-\frac{i}{numSteps})$$

अंतिम परिणाम सभी आंशिक का अधिकतम प्रकाश कारक है:

$$

$$SF=max(PSF_i)$$

विधि की योजना:

इस उदाहरण में तीन पुनरावृत्तियों के लिए विधि की प्रगति:

• हम कुल प्रकाश कारक को शून्य से शुरू करते हैं।
• वेक्टर के साथ एक कदम उठाएं $$ˉ L , बिंदु पर पहुंचना$\color{green}{\bar{L}}$$$$H_a$ । बिंदु की गहराई मानचित्र से चयन से स्पष्ट रूप से कम है। $$एच ( टी एल 1 ) - यह सतह के नीचे है। यहां हमने पहला चेक बनाया और, चेक की कुल संख्या को याद करते हुए, हम पहले आंशिक प्रकाश कारक को खोजते हैं और बचाते हैं: (1.0 - 1.0 / 3.0)।$H(T_{L1})$
• वेक्टर के साथ एक कदम उठाएं $$ˉ L , बिंदु पर पहुंचना$\color{green}{\bar{L}}$$$$H_b$ । बिंदु की गहराई मानचित्र से चयन से स्पष्ट रूप से कम है। $$एच ( टी एल 2 ) - यह सतह के नीचे है। दूसरा चेक और दूसरा आंशिक गुणांक: (1.0 - 2.0 / 3.0)।$H(T_{L2})$
• हम वेक्टर के साथ एक और कदम उठाते हैं और 0. की न्यूनतम गहराई तक पहुँचते हैं।
• परिणाम की परिभाषा: यदि सतह के नीचे कोई अंक नहीं मिला, तो हम 1 (कोई छायांकन) के बराबर गुणांक लौटाते हैं। अन्यथा, परिणामी गुणांक की गणना आंशिक वाले की अधिकतम हो जाती है। प्रकाश गणना में उपयोग के लिए, हम इस मूल्य को एकता से घटाते हैं।

शेडर कोड उदाहरण:

 //  : inTexCoords -   , // inLightDir -       - //  : inLastDepth –    , //      PM //       //    float getParallaxSelfShadow(vec2 inTexCoords, vec3 inLightDir, float inLastDepth) { float shadowMultiplier = 0.; //      , //    float alignFactor = dot(vec3(0., 0., 1.), inLightDir); if (alignFactor > 0.) { //   :  ,  //  ,     const float _minLayers = 16.; const float _maxLayers = 32.; float _numLayers = mix(_maxLayers, _minLayers, abs(alignFactor)); float _dDepth = inLastDepth/_numLayers; vec2 _dtex = uDepthScale * inLightDir.xy/(inLightDir.z * _numLayers); //  ,    int numSamplesUnderSurface = 0; //       //     L float currentLayerDepth = inLastDepth - _dDepth; vec2 currentTexCoords = inTexCoords + _dtex; float currentDepthValue = depthValue(currentTexCoords); //    float stepIndex = 1.; // ,       … while (currentLayerDepth > 0.) { //     ,     //       if (currentDepthValue < currentLayerDepth) { numSamplesUnderSurface++; float currentShadowMultiplier = (currentLayerDepth - currentDepthValue)*(1. - stepIndex/_numLayers); shadowMultiplier = max(shadowMultiplier, currentShadowMultiplier); } stepIndex++; currentLayerDepth -= _dDepth; currentTexCoords += _dtex; currentDepthValue = depthValue(currentTexCoords); } //      ,   //      1 if (numSamplesUnderSurface < 1) shadowMultiplier = 1.; else shadowMultiplier = 1. - shadowMultiplier; } return shadowMultiplier; } 

परिणामी गुणांक का उपयोग उदाहरणों में प्रयुक्त ब्लिन-फोंग लाइटिंग मॉडल के परिणाम को संशोधित करने के लिए किया जाता है:

 [...] //      vec3 fullColorADS = ambientTerm + attenuation * (diffuseTerm + specularTerm); //     -  fullColorADS *= pmShadowMultiplier; return fullColorADS; 

सभी तरीकों की तुलना एक महाविद्यालय में, 3MB की मात्रा।

इसके अलावा एक वीडियो तुलना:

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

• लंबन GLSL में रोड़ा मानचित्रण : लंबन मानचित्रण से एक महान सबक sunandblackcat.com ।
• लंबन विस्थापन मानचित्रण कैसे काम करता है : एक वीडियो ट्यूटोरियल जो TheBennyBox द्वारा लंबन मानचित्रण के विवरण को समझाता है ।

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