🎡 🦍 👩🏽‍⚖️ The Witcher 3 के प्रतिपादन की रिवर्स इंजीनियरिंग: विभिन्न आकाश प्रभाव ♾ 🧛 👊🏽

[विश्लेषण के पिछले हिस्से: पहला और दूसरा और तीसरा ।]

भाग 1. सिरस बादल

जब खेल खुले स्थानों पर होता है, तो दुनिया की विश्वसनीयता निर्धारित करने वाले कारकों में से एक आकाश है। इसके बारे में सोचो - ज्यादातर समय आकाश सचमुच पूरी स्क्रीन का लगभग 40-50% लेता है। आकाश एक सुंदर ढाल से बहुत अधिक है। इसमें तारे, सूर्य, चंद्रमा और अंत में बादल हैं।

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

इस Witcher 3 में बादलों की कई परतें हैं। मौसम के आधार पर, यह केवल सिरस के बादल , उच्च क्यूम्यलस बादल , संभवतः स्तरित बादलों के परिवार से कुछ बादल (उदाहरण के लिए, एक तूफान के दौरान) हो सकते हैं। अंत में, कोई बादल नहीं हो सकता है।

कुछ परतें उन्हें रेंडर करने के लिए उपयोग किए जाने वाले बनावट और शेड के संदर्भ में भिन्न होती हैं। जाहिर है, यह पिक्सेल shader के लिए कोडांतरक कोड की जटिलता और लंबाई को प्रभावित करता है।

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

अधिक दिलचस्प रूप से, कुछ परतें एक ही पैरामीटर के साथ दो बार प्रदान की जाती हैं।

कोड को देखने के बाद, मैंने (1) सबसे पूर्ण संभावित रूप से इसके पूर्ण रिवर्स इंजीनियरिंग का प्रदर्शन करने के लिए सबसे छोटा शेडर चुना, (2) इसके सभी पहलुओं का पता लगाया।

मैंने चुड़ैल 3: रक्त और शराब से सिरस बादलों पर करीब से नज़र डाली।

यहाँ एक उदाहरण फ्रेम है:

रेंडर करने से पहले

पहले रेंडर पास होने के बाद

दूसरे रेंडरिंग पास के बाद

इस विशेष फ्रेम में, रेंडर करते समय सिरस क्लाउड पहली परत होती है। जैसा कि आप देख सकते हैं, यह दो बार गाया जाता है, जिससे इसकी चमक बढ़ जाती है।

जियोमेट्रिक और वर्टेक्स शेडर

पिक्सेल shader से पहले, हम उपयोग किए गए ज्यामितीय और शीर्ष shaders के बारे में संक्षेप में बात करेंगे। बादलों को प्रदर्शित करने के लिए जाली एक नियमित आकाश गुंबद की तरह है:

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

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

पिक्सेल shader

पिक्सेल shader असेंबली कोड इस तरह दिखता है:

 ps_5_0  
    dcl_globalFlags refactoringAllowed  
    dcl_constantbuffer cb0[10], immediateIndexed  
    dcl_constantbuffer cb1[9], immediateIndexed  
    dcl_constantbuffer cb12[238], immediateIndexed  
    dcl_constantbuffer cb4[13], immediateIndexed  
    dcl_sampler s0, mode_default  
    dcl_resource_texture2d (float,float,float,float) t0  
    dcl_resource_texture2d (float,float,float,float) t1  
    dcl_input_ps linear v0.xyzw  
    dcl_input_ps linear v1.xyzw  
    dcl_input_ps linear v2.w  
    dcl_input_ps linear v3.xyzw  
    dcl_input_ps linear v4.xyz  
    dcl_input_ps linear v5.xyz  
    dcl_output o0.xyzw  
    dcl_temps 4  
   0: mul r0.xyz, cb0[9].xyzx, l(1.000000, 1.000000, -1.000000, 0.000000)  
   1: dp3 r0.w, r0.xyzx, r0.xyzx  
   2: rsq r0.w, r0.w  
   3: mul r0.xyz, r0.wwww, r0.xyzx  
   4: mul r1.xy, cb0[0].xxxx, cb4[5].xyxx  
   5: mad r1.xy, v1.xyxx, cb4[4].xyxx, r1.xyxx  
   6: sample_indexable(texture2d)(float,float,float,float) r1.xyzw, r1.xyxx, t0.xyzw, s0  
   7: add r1.xyz, r1.xyzx, l(-0.500000, -0.500000, -0.500000, 0.000000)  
   8: add r1.xyz, r1.xyzx, r1.xyzx  
   9: dp3 r0.w, r1.xyzx, r1.xyzx  
  10: rsq r0.w, r0.w  
  11: mul r1.xyz, r0.wwww, r1.xyzx  
  12: mul r2.xyz, r1.yyyy, v3.xyzx  
  13: mad r2.xyz, v5.xyzx, r1.xxxx, r2.xyzx  
  14: mov r3.xy, v1.zwzz  
  15: mov r3.z, v3.w  
  16: mad r1.xyz, r3.xyzx, r1.zzzz, r2.xyzx  
  17: dp3_sat r0.x, r0.xyzx, r1.xyzx  
  18: add r0.y, -cb4[2].x, cb4[3].x  
  19: mad r0.x, r0.x, r0.y, cb4[2].x  
  20: dp2 r0.y, -cb0[9].xyxx, -cb0[9].xyxx  
  21: rsq r0.y, r0.y  
  22: mul r0.yz, r0.yyyy, -cb0[9].xxyx  
  23: add r1.xyz, -v4.xyzx, cb1[8].xyzx  
  24: dp3 r0.w, r1.xyzx, r1.xyzx  
  25: rsq r1.z, r0.w  
  26: sqrt r0.w, r0.w  
  27: add r0.w, r0.w, -cb4[7].x  
  28: mul r1.xy, r1.zzzz, r1.xyxx  
  29: dp2_sat r0.y, r0.yzyy, r1.xyxx  
  30: add r0.y, r0.y, r0.y  
  31: min r0.y, r0.y, l(1.000000)  
  32: add r0.z, -cb4[0].x, cb4[1].x  
  33: mad r0.z, r0.y, r0.z, cb4[0].x  
  34: mul r0.x, r0.x, r0.z  
  35: log r0.x, r0.x  
  36: mul r0.x, r0.x, l(2.200000)  
  37: exp r0.x, r0.x  
  38: add r1.xyz, cb12[236].xyzx, -cb12[237].xyzx  
  39: mad r1.xyz, r0.yyyy, r1.xyzx, cb12[237].xyzx  
  40: mul r2.xyz, r0.xxxx, r1.xyzx  
  41: mad r0.xyz, -r1.xyzx, r0.xxxx, v0.xyzx  
  42: mad r0.xyz, v0.wwww, r0.xyzx, r2.xyzx  
  43: add r1.x, -cb4[7].x, cb4[8].x  
  44: div_sat r0.w, r0.w, r1.x  
  45: mul r1.x, r1.w, cb4[9].x  
  46: mad r1.y, -cb4[9].x, r1.w, r1.w  
  47: mad r0.w, r0.w, r1.y, r1.x  
  48: mul r1.xy, cb0[0].xxxx, cb4[11].xyxx  
  49: mad r1.xy, v1.xyxx, cb4[10].xyxx, r1.xyxx  
  50: sample_indexable(texture2d)(float,float,float,float) r1.x, r1.xyxx, t1.xyzw, s0  
  51: mad r1.x, r1.x, cb4[12].x, -cb4[12].x  
  52: mad_sat r1.x, cb4[12].x, v2.w, r1.x  
  53: mul r0.w, r0.w, r1.x  
  54: mul_sat r0.w, r0.w, cb4[6].x  
  55: mul o0.xyz, r0.wwww, r0.xyzx  
  56: mov o0.w, r0.w  
  57: ret

दो निर्बाध बनावट इनपुट हैं। उनमें से एक में एक सामान्य मानचित्र ( xyz चैनल ) और एक क्लाउड आकार (चैनल a ) है। दूसरा आकार को विकृत करने के लिए शोर है।

सामान्य नक्शा, सीडी प्रॉजेक्ट रेड प्रॉपर्टी

क्लाउड शेप, प्रॉपर्टी सीडी प्रॉजेक्ट रेड

शोर बनावट, सीडी प्रॉजेक्ट रेड

की संपत्ति क्लाउड मापदंडों के साथ स्थिरांक का मुख्य बफर cb4 है। इस फ्रेम के लिए, इसके निम्नलिखित अर्थ हैं:

इसके अलावा, अन्य cbuffers से अन्य मूल्यों का उपयोग किया जाता है। चिंता न करें, हम उन पर भी विचार करेंगे।

Z- दिशा उलटी धूप

पहली चीज जो कि छाया में होती है, वह Z अक्ष के साथ उल्टे सूर्य के प्रकाश की सामान्यीकृत दिशा की गणना है:

   0: mul r0.xyz, cb0[9].xyzx, l(1.000000, 1.000000, -1.000000, 0.000000)  
   1: dp3 r0.w, r0.xyzx, r0.xyzx  
   2: rsq r0.w, r0.w  
   3: mul r0.xyz, r0.wwww, r0.xyzx  

   float3 invertedSunlightDir = normalize(lightDir * float3(1, 1, -1) );

जैसा कि पहले उल्लेख किया गया है, Z अक्ष ऊपर की ओर निर्देशित है, और cb0 [9] सूर्य के प्रकाश की दिशा है। यह वेक्टर सूर्य पर लक्षित है - यह महत्वपूर्ण है! आप इसे एक सरल कम्प्यूटेशनल शेडर लिखकर सत्यापित कर सकते हैं जो एक सरल एनडीओटीएल चलाता है, और इसे आस्थगित शेप पास में सम्मिलित करता है।

क्लाउड टेक्सचर सैंपलिंग

अगला कदम टेक्सकोर्ड्स को क्लाउड बनावट का नमूना देने, सामान्य वेक्टर को अनपैक करने और इसे सामान्य करने के लिए है।

   4: mul r1.xy, cb0[0].xxxx, cb4[5].xyxx   
   5: mad r1.xy, v1.xyxx, cb4[4].xyxx, r1.xyxx   
   6: sample_indexable(texture2d)(float,float,float,float) r1.xyzw, r1.xyxx, t0.xyzw, s0   
   7: add r1.xyz, r1.xyzx, l(-0.500000, -0.500000, -0.500000, 0.000000)   
   8: add r1.xyz, r1.xyzx, r1.xyzx   
   9: dp3 r0.w, r1.xyzx, r1.xyzx   
  10: rsq r0.w, r0.w   
   
   
   // Calc sampling coords  
   float2 cloudTextureUV = Texcoords * textureScale + elapsedTime * speedFactors;  
   
   // Sample texture and get data from it  
   float4 cloudTextureValue = texture0.Sample( sampler0, cloudTextureUV ).rgba;  
   float3 normalMap = cloudTextureValue.xyz;  
   float cloudShape = cloudTextureValue.a;  
   
   // Unpack normal and normalize it  
   float3 unpackedNormal = (normalMap - 0.5) * 2.0;  
   unpackedNormal = normalize(unpackedNormal);

इससे धीरे-धीरे निपटते हैं।

बादलों की गति प्राप्त करने के लिए, हमें गति (गुणांक) में ( cb [0] .x ) गुणा समय की आवश्यकता होती है , जो आकाश में बादलों के चलने की गति ( cb4 [5] .xy ) को प्रभावित करता है ।

जैसा कि मैंने पहले कहा, UVs आकाश गुंबद की ज्यामिति के साथ खिंचे हुए हैं, और हमें बनावट स्केलिंग कारकों की भी आवश्यकता है जो बादलों के आकार को प्रभावित करते हैं ( cb4 [4] .xy )।

अंतिम सूत्र है:

samplingUV = Input.TextureUV * textureScale + time * speedMultiplier;

सभी 4 चैनलों का नमूना लेने के बाद, हमारे पास एक सामान्य नक्शा (आरजीबी चैनल) और एक क्लाउड आकार (चैनल) है।

अंतराल से सामान्य मानचित्र को अनपैक करने के लिए [0; 1] अंतराल में [-1; 1] हम निम्नलिखित सूत्र का उपयोग करते हैं:

unpackedNormal = (packedNormal - 0.5) * 2.0;

आप इसका उपयोग भी कर सकते हैं:

unpackedNormal = packedNormal * 2.0 - 1.0;

अंत में, हम अनपैक्ड सामान्य वेक्टर को सामान्य करते हैं।

ओवरले मानदंड

सामान्य वैक्टर, स्पर्शरेखा और द्वि-स्पर्शरेखा वैक्टर वैक्टर शीर्ष छायाकार से, और सामान्य वेक्टर से सामान्य वेक्टर, हम सामान्य रूप से मानदंडों को मैप करते हैं।

  11: mul r1.xyz, r0.wwww, r1.xyzx  
  12: mul r2.xyz, r1.yyyy, v3.xyzx  
  13: mad r2.xyz, v5.xyzx, r1.xxxx, r2.xyzx  
  14: mov r3.xy, v1.zwzz  
  15: mov r3.z, v3.w  
  16: mad r1.xyz, r3.xyzx, r1.zzzz, r2.xyzx  
    
   // Perform bump mapping  
   float3 SkyTangent = Input.Tangent;  
   float3 SkyNormal = (float3( Input.Texcoords.zw, Input.param3.w ));  
   float3 SkyBitangent = Input.param3.xyz;  
        
   float3x3 TBN = float3x3(SkyTangent, SkyBitangent, SkyNormal);  
   float3 finalNormal = (float3)mul( unpackedNormal, (TBN) );

चमक (1)

अगले चरण में, एनडीओटीएल गणना लागू की जाती है और यह एक विशिष्ट पिक्सेल की रोशनी की मात्रा को प्रभावित करता है।

निम्नलिखित कोडांतरक कोड पर विचार करें:

  17: dp3_sat r0.x, r0.xyzx, r1.xyzx  
  18: add r0.y, -cb4[2].x, cb4[3].x  
  19: mad r0.x, r0.x, r0.y, cb4[2].x

यहाँ प्रश्न में फ्रेम पर NdotL का दृश्य है:

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

   // Calculate cosine between normal and up-inv lightdir  
   float NdotL = saturate( dot(invertedSunlightDir, finalNormal) );  
   
   // Param 1, line 19, r0.x  
   float intensity1 = lerp( param1Min, param1Max, NdotL );

चमक (2)

बादलों की चमक को प्रभावित करने वाला एक और कारक है।

आकाश के उस हिस्से में स्थित बादल जहां सूरज है, अधिक प्रकाश डाला जाना चाहिए। ऐसा करने के लिए, हम एक्सवाई प्लेन के आधार पर ग्रेडिएंट की गणना करते हैं।

इस ढाल का उपयोग न्यूनतम / अधिकतम मूल्यों के बीच रैखिक प्रक्षेप की गणना करने के लिए किया जाता है, जो कि भाग (1) में होता है।

यही है, सैद्धांतिक रूप से, हम सूर्य के विपरीत दिशा में स्थित बादलों को काला करने के लिए कह सकते हैं, लेकिन इस विशेष फ्रेम में ऐसा नहीं होता है, क्योंकि param2Min और param2Max ( cb4 [0] .x and c44 [1] .x ) 1.0f पर सेट हैं।

  20: dp2 r0.y, -cb0[9].xyxx, -cb0[9].xyxx  
  21: rsq r0.y, r0.y  
  22: mul r0.yz, r0.yyyy, -cb0[9].xxyx  
  23: add r1.xyz, -v4.xyzx, cb1[8].xyzx  
  24: dp3 r0.w, r1.xyzx, r1.xyzx  
  25: rsq r1.z, r0.w  
  26: sqrt r0.w, r0.w  
  27: add r0.w, r0.w, -cb4[7].x  
  28: mul r1.xy, r1.zzzz, r1.xyxx  
  29: dp2_sat r0.y, r0.yzyy, r1.xyxx  
  30: add r0.y, r0.y, r0.y  
  31: min r0.y, r0.y, l(1.000000)  
  32: add r0.z, -cb4[0].x, cb4[1].x  
  33: mad r0.z, r0.y, r0.z, cb4[0].x  
  34: mul r0.x, r0.x, r0.z  
  35: log r0.x, r0.x  
  36: mul r0.x, r0.x, l(2.200000)  
  37: exp r0.x, r0.x   
   
   
   // Calculate normalized -lightDir.xy (20-22)  
   float2 lightDirXY = normalize( -lightDir.xy );  
   
   // Calculate world to camera  
   float3 vWorldToCamera = ( CameraPos - WorldPos );  
   float worldToCamera_distance = length(vWorldToCamera);  
        
   // normalize vector  
   vWorldToCamera = normalize( vWorldToCamera );  
        
   
   float LdotV = saturate( dot(lightDirXY, vWorldToCamera.xy) );  
   float highlightedSkySection = saturate( 2*LdotV );  
   float intensity2 = lerp( param2Min, param2Max, highlightedSkySection );  
   
   float finalIntensity = pow( intensity2 *intensity1, 2.2);

बहुत अंत में, हम दोनों चमक बढ़ाते हैं और परिणाम को 2.2 की शक्ति तक बढ़ाते हैं।

बादल का रंग

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

तब परिणाम अंतिम गुणन द्वारा गुणा किया जाता है ।

और अंत में, परिणाम कोहरे के साथ मिलाया जाता है (प्रदर्शन कारणों के लिए, यह वर्टिकल शेडर द्वारा गणना की गई थी)।

  38: add r1.xyz, cb12[236].xyzx, -cb12[237].xyzx  
  39: mad r1.xyz, r0.yyyy, r1.xyzx, cb12[237].xyzx  
  40: mul r2.xyz, r0.xxxx, r1.xyzx  
  41: mad r0.xyz, -r1.xyzx, r0.xxxx, v0.xyzx  
  42: mad r0.xyz, v0.wwww, r0.xyzx, r2.xyzx  
   
  float3 cloudsColor = lerp( cloudsColorBack, cloudsColorFront, highlightedSunSection );  
  cloudsColor *= finalIntensity;  
  cloudsColor = lerp( cloudsColor, FogColor, FogAmount );

क्षितिज पर सिरस के बादल अधिक दिखाई देते हैं

यह फ्रेम पर बहुत ध्यान देने योग्य नहीं है, लेकिन वास्तव में यह परत गेराल्ट के सिर के ऊपर क्षितिज के पास अधिक दिखाई देती है। यहाँ यह कैसे करना है।

आप देख सकते हैं कि दूसरी चमक की गणना करते समय, हमने वेक्टर वर्ल्डटॉम्केरा की लंबाई की गणना की :

  23: add r1.xyz, -v4.xyzx, cb1[8].xyzx  
  24: dp3 r0.w, r1.xyzx, r1.xyzx  
  25: rsq r1.z, r0.w  
  26: sqrt r0.w, r0.w

आइए कोड में इस लंबाई की निम्नलिखित घटनाओं को खोजें:

  26: sqrt r0.w, r0.w  
  27: add r0.w, r0.w, -cb4[7].x  
  ...  
  43: add r1.x, -cb4[7].x, cb4[8].x  
  44: div_sat r0.w, r0.w, r1.x

वाह, यह हमारे साथ क्या है?

cb [7] .x और cb [8] .x का मान 2000.0 और 7000.0 है।

यह पता चला है कि यह लिनस्टेप फ़ंक्शन का उपयोग करने का परिणाम है ।

उसे तीन पैरामीटर मिलते हैं: न्यूनतम / अधिकतम - अंतराल और वी - मान।

यह निम्नानुसार काम करता है: यदि v अंतराल [ मिनट - अधिकतम ] में है, तो फ़ंक्शन अंतराल [0.0 - 1.0] में रैखिक प्रक्षेप करता है। दूसरी ओर, यदि v सीमा से बाहर है, तो linstep 0.0 या 1.0 देता है।

एक सरल उदाहरण:

linstep( 1000.0, 2000.0, 999.0) = 0.0
linstep( 1000.0, 2000.0, 1500.0) = 0.5
linstep( 1000.0, 2000.0, 2000.0) = 1.0

यही है, यह एचएलएसएल से स्मूथस्टेप के समान है , सिवाय इसके कि इस मामले में, हर्मिटियन प्रक्षेप के बजाय, रैखिक प्रदर्शन किया जाता है।

लिनस्टेप HLSL में एक विशेषता नहीं है, लेकिन यह बहुत उपयोगी है। यह आपके टूलकिट में होने के लायक है।

 // linstep:  
 //  
 // Returns a linear interpolation between 0 and 1 if t is in the range [min, max]   
 // if "v" is <= min, the output is 0  
 // if "v" i >= max, the output is 1  
   
 float linstep( float min, float max, float v )  
 {  
   return saturate( (v - min) / (max - min) );  
 }

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

  45: mul r1.x, r1.w, cb4[9].x  
  46: mad r1.y, -cb4[9].x, r1.w, r1.w  
  47: mad r0.w, r0.w, r1.y, r1.x  
   
   float distanceAttenuation = linstep( fadeDistanceStart, fadeDistanceEnd, worldToCamera_distance );  
    
   float fadedCloudShape = closeCloudsHidingFactor * cloudShape;  
   cloudShape = lerp( fadedCloudShape, cloudShape, distanceAttenuation );

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

शोर बनावट नमूना

बादलों की बनावट के लिए समान शोर बनावट के नमूने के निर्देशांक की गणना, सिवाय इसके कि आप बनावट सेटसेल और स्पीडमूलिपियर के एक अलग सेट का उपयोग करें ।

बेशक, इन सभी बनावटों के नमूने के लिए सक्षम रैपिंग मोडिंग मोड के साथ एक नमूना का उपयोग किया जाता है ।

  48: mul r1.xy, cb0[0].xxxx, cb4[11].xyxx  
  49: mad r1.xy, v1.xyxx, cb4[10].xyxx, r1.xyxx  
  50: sample_indexable(texture2d)(float,float,float,float) r1.x, r1.xyxx, t1.xyzw, s0  
   
   // Calc sampling coords for noise  
   float2 noiseTextureUV = Texcoords * textureScaleNoise + elapsedTime * speedFactorsNoise;  
   
   // Sample texture and get data from it  
   float noiseTextureValue = texture1.Sample( sampler0, noiseTextureUV ).x;

यह सब एक साथ डालें

शोर मूल्य प्राप्त करने के बाद, हमें इसे क्लाउडशेप के साथ जोड़ना होगा।

मुझे इन पंक्तियों को समझने में कुछ समस्याएँ थीं, जहाँ param2.w है (जो कि हमेशा 1.0 है) और नॉइज़मुल्ट (जिसका मान 5.0 है, स्थिर बफर से लिया गया है)।

जैसा कि यह हो सकता है, यहां सबसे महत्वपूर्ण बात यह है कि generalCloudsVisibility का अंतिम मूल्य है , जो बादलों की दृश्यता को प्रभावित करता है।

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

  51: mad r1.x, r1.x, cb4[12].x, -cb4[12].x
  52: mad_sat r1.x, cb4[12].x, v2.w, r1.x
  53: mul r0.w, r0.w, r1.x
  54: mul_sat r0.w, r0.w, cb4[6].x
  55: mul o0.xyz, r0.wwww, r0.xyzx
  56: mov o0.w, r0.w
  57: ret   

   // Sample noise texture and get data from it  
   float noiseTextureValue = texture1.Sample( sampler0, noiseTextureUV ).x;  
   noiseTextureValue = noiseTextureValue * noiseMult - noiseMult;  
     
   float noiseValue = saturate( noiseMult * Input.param2.w + noiseTextureValue);  
   noiseValue *= cloudShape;  
     
   float finalNoise = saturate( noiseValue * generalCloudsVisibility);  
   
   return float4( cloudsColor*finalNoise, finalNoise );

संपूर्ण

तैयार परिणाम बहुत विश्वसनीय लगता है।

आप तुलना कर सकते हैं। पहली तस्वीर मेरी शेडर की है, दूसरी गेम शैडर की है:

यदि आप जिज्ञासु हैं, तो यहां shader उपलब्ध है ।

भाग 2. कोहरा

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

कोहरे के प्रतिपादन में वर्तमान रुझान कम्प्यूटेशनल शेड्स (विवरण के लिए, बार्ट व्रोनस्की द्वारा इस प्रस्तुति को देखें ) पर आधारित हैं।

इस तथ्य के बावजूद कि यह प्रस्तुति 2014 में प्रदर्शित हुई थी, और द विचर 3 2015/2016 में रिलीज़ हुई थी, गेराल्ट के कारनामों के अंतिम भाग में कोहरा पूरी तरह से स्क्रीन पर निर्भर है और इसे एक विशिष्ट पोस्ट-प्रोसेसिंग के रूप में लागू किया गया है।

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

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

यहाँ पिक्सेल कोहरे shader के लिए कोडांतरक कोड है - यह ध्यान देने योग्य है कि यह पूरे खेल (2015 के मुख्य भाग और दोनों डीएलसी) के लिए समान है:

 ps_5_0  
    dcl_globalFlags refactoringAllowed  
    dcl_constantbuffer cb3[2], immediateIndexed  
    dcl_constantbuffer cb12[214], immediateIndexed  
    dcl_resource_texture2d (float,float,float,float) t0  
    dcl_resource_texture2d (float,float,float,float) t1  
    dcl_resource_texture2d (float,float,float,float) t2  
    dcl_input_ps_siv v0.xy, position  
    dcl_output o0.xyzw  
    dcl_temps 7  
   0: ftou r0.xy, v0.xyxx  
   1: mov r0.zw, l(0, 0, 0, 0)  
   2: ld_indexable(texture2d)(float,float,float,float) r1.x, r0.xyww, t0.xyzw  
   3: mad r1.y, r1.x, cb12[22].x, cb12[22].y  
   4: lt r1.y, r1.y, l(1.000000)  
   5: if_nz r1.y  
   6:  utof r1.yz, r0.xxyx  
   7:  mul r2.xyzw, r1.zzzz, cb12[211].xyzw  
   8:  mad r2.xyzw, cb12[210].xyzw, r1.yyyy, r2.xyzw  
   9:  mad r1.xyzw, cb12[212].xyzw, r1.xxxx, r2.xyzw  
  10:  add r1.xyzw, r1.xyzw, cb12[213].xyzw  
  11:  div r1.xyz, r1.xyzx, r1.wwww  
  12:  ld_indexable(texture2d)(float,float,float,float) r2.xyz, r0.xyww, t1.xyzw  
  13:  ld_indexable(texture2d)(float,float,float,float) r0.x, r0.xyzw, t2.xyzw  
  14:  max r0.x, r0.x, cb3[1].x  
  15:  add r0.yzw, r1.xxyz, -cb12[0].xxyz  
  16:  dp3 r1.x, r0.yzwy, r0.yzwy  
  17:  sqrt r1.x, r1.x  
  18:  add r1.y, r1.x, -cb3[0].x  
  19:  add r1.zw, -cb3[0].xxxz, cb3[0].yyyw  
  20:  div_sat r1.y, r1.y, r1.z  
  21:  mad r1.y, r1.y, r1.w, cb3[0].z  
  22:  add r0.x, r0.x, l(-1.000000)  
  23:  mad r0.x, r1.y, r0.x, l(1.000000)  
  24:  div r0.yzw, r0.yyzw, r1.xxxx  
  25:  mad r1.y, r0.w, cb12[22].z, cb12[0].z  
  26:  add r1.x, r1.x, -cb12[22].z  
  27:  max r1.x, r1.x, l(0)  
  28:  min r1.x, r1.x, cb12[42].z  
  29:  mul r1.z, r0.w, r1.x  
  30:  mul r1.w, r1.x, cb12[43].x  
  31:  mul r1.zw, r1.zzzw, l(0.000000, 0.000000, 0.062500, 0.062500)  
  32:  dp3 r0.y, cb12[38].xyzx, r0.yzwy  
  33:  add r0.z, r0.y, cb12[42].x  
  34:  add r0.w, cb12[42].x, l(1.000000)  
  35:  div_sat r0.z, r0.z, r0.w  
  36:  add r0.w, -cb12[43].z, cb12[43].y  
  37:  mad r0.z, r0.z, r0.w, cb12[43].z  
  38:  mul r0.w, abs(r0.y), abs(r0.y)  
  39:  mad_sat r2.w, r1.x, l(0.002000), l(-0.300000)  
  40:  mul r0.w, r0.w, r2.w  
  41:  lt r0.y, l(0), r0.y  
  42:  movc r3.xyz, r0.yyyy, cb12[39].xyzx, cb12[41].xyzx  
  43:  add r3.xyz, r3.xyzx, -cb12[40].xyzx  
  44:  mad r3.xyz, r0.wwww, r3.xyzx, cb12[40].xyzx  
  45:  movc r4.xyz, r0.yyyy, cb12[45].xyzx, cb12[47].xyzx  
  46:  add r4.xyz, r4.xyzx, -cb12[46].xyzx  
  47:  mad r4.xyz, r0.wwww, r4.xyzx, cb12[46].xyzx  
  48:  ge r0.y, r1.x, cb12[48].y  
  49:  if_nz r0.y  
  50:   add r0.y, r1.y, cb12[42].y  
  51:   mul r0.w, r0.z, r0.y  
  52:   mul r1.y, r0.z, r1.z  
  53:   mad r5.xyzw, r1.yyyy, l(16.000000, 15.000000, 14.000000, 13.000000), r0.wwww  
  54:   max r5.xyzw, r5.xyzw, l(0, 0, 0, 0)  
  55:   add r5.xyzw, r5.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000)  
  56:   div_sat r5.xyzw, r1.wwww, r5.xyzw  
  57:   add r5.xyzw, -r5.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000)  
  58:   mul r1.z, r5.y, r5.x  
  59:   mul r1.z, r5.z, r1.z  
  60:   mul r1.z, r5.w, r1.z  
  61:   mad r5.xyzw, r1.yyyy, l(12.000000, 11.000000, 10.000000, 9.000000), r0.wwww  
  62:   max r5.xyzw, r5.xyzw, l(0, 0, 0, 0)  
  63:   add r5.xyzw, r5.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000)  
  64:   div_sat r5.xyzw, r1.wwww, r5.xyzw  
  65:   add r5.xyzw, -r5.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000)  
  66:   mul r1.z, r1.z, r5.x  
  67:   mul r1.z, r5.y, r1.z  
  68:   mul r1.z, r5.z, r1.z  
  69:   mul r1.z, r5.w, r1.z  
  70:   mad r5.xyzw, r1.yyyy, l(8.000000, 7.000000, 6.000000, 5.000000), r0.wwww  
  71:   max r5.xyzw, r5.xyzw, l(0, 0, 0, 0)  
  72:   add r5.xyzw, r5.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000)  
  73:   div_sat r5.xyzw, r1.wwww, r5.xyzw  
  74:   add r5.xyzw, -r5.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000)  
  75:   mul r1.z, r1.z, r5.x  
  76:   mul r1.z, r5.y, r1.z  
  77:   mul r1.z, r5.z, r1.z  
  78:   mul r1.z, r5.w, r1.z  
  79:   mad r5.xy, r1.yyyy, l(4.000000, 3.000000, 0.000000, 0.000000), r0.wwww  
  80:   max r5.xy, r5.xyxx, l(0, 0, 0, 0)  
  81:   add r5.xy, r5.xyxx, l(1.000000, 1.000000, 0.000000, 0.000000)  
  82:   div_sat r5.xy, r1.wwww, r5.xyxx  
  83:   add r5.xy, -r5.xyxx, l(1.000000, 1.000000, 0.000000, 0.000000)  
  84:   mul r1.z, r1.z, r5.x  
  85:   mul r1.z, r5.y, r1.z  
  86:   mad r0.w, r1.y, l(2.000000), r0.w  
  87:   max r0.w, r0.w, l(0)  
  88:   add r0.w, r0.w, l(1.000000)  
  89:   div_sat r0.w, r1.w, r0.w  
  90:   add r0.w, -r0.w, l(1.000000)  
  91:   mul r0.w, r0.w, r1.z  
  92:   mad r0.y, r0.y, r0.z, r1.y  
  93:   max r0.y, r0.y, l(0)  
  94:   add r0.y, r0.y, l(1.000000)  
  95:   div_sat r0.y, r1.w, r0.y  
  96:   add r0.y, -r0.y, l(1.000000)  
  97:   mad r0.y, -r0.w, r0.y, l(1.000000)  
  98:   add r0.z, r1.x, -cb12[48].y  
  99:   mul_sat r0.z, r0.z, cb12[48].z  
  100:  else  
  101:   mov r0.yz, l(0.000000, 1.000000, 0.000000, 0.000000)  
  102:  endif  
  103:  log r0.y, r0.y  
  104:  mul r0.w, r0.y, cb12[42].w  
  105:  exp r0.w, r0.w  
  106:  mul r0.y, r0.y, cb12[48].x  
  107:  exp r0.y, r0.y  
  108:  mul r0.yw, r0.yyyw, r0.zzzz  
  109:  mad_sat r1.xy, r0.wwww, cb12[189].xzxx, cb12[189].ywyy  
  110:  add r5.xyz, -r3.xyzx, cb12[188].xyzx  
  111:  mad r5.xyz, r1.xxxx, r5.xyzx, r3.xyzx  
  112:  add r0.z, cb12[188].w, l(-1.000000)  
  113:  mad r0.z, r1.y, r0.z, l(1.000000)  
  114:  mul_sat r5.w, r0.z, r0.w  
  115:  lt r0.z, l(0), cb12[192].x  
  116:  if_nz r0.z  
  117:   mad_sat r1.xy, r0.wwww, cb12[191].xzxx, cb12[191].ywyy  
  118:   add r6.xyz, -r3.xyzx, cb12[190].xyzx  
  119:   mad r3.xyz, r1.xxxx, r6.xyzx, r3.xyzx  
  120:   add r0.z, cb12[190].w, l(-1.000000)  
  121:   mad r0.z, r1.y, r0.z, l(1.000000)  
  122:   mul_sat r3.w, r0.z, r0.w  
  123:   add r1.xyzw, -r5.xyzw, r3.xyzw  
  124:   mad r5.xyzw, cb12[192].xxxx, r1.xyzw, r5.xyzw  
  125:  endif  
  126:  mul r0.z, r0.x, r5.w  
  127:  mul r0.x, r0.x, r0.y  
  128:  dp3 r0.y, l(0.333000, 0.555000, 0.222000, 0.000000), r2.xyzx  
  129:  mad r1.xyz, r0.yyyy, r4.xyzx, -r2.xyzx  
  130:  mad r0.xyw, r0.xxxx, r1.xyxz, r2.xyxz  
  131:  add r1.xyz, -r0.xywx, r5.xyzx  
  132:  mad r0.xyz, r0.zzzz, r1.xyzx, r0.xywx  
  133: else  
  134:  mov r0.xyz, l(0, 0, 0, 0)  
  135: endif  
  136: mov o0.xyz, r0.xyzx  
  137: mov o0.w, l(1.000000)  
  138: ret

ईमानदारी से, शेडर काफी लंबा है। शायद एक प्रभावी रिवर्स इंजीनियरिंग प्रक्रिया के लिए बहुत लंबा है।

यहाँ कोहरे के साथ सूर्यास्त का एक उदाहरण दिया गया है:

आइए इनपुट पर एक नज़र डालें:

जैसा कि बनावट के लिए, हमारे पास एक गहराई बफर, एम्बिएंट समावेश, और एक एचडीआर रंग बफर है।

भीतर की गहराई बफर

आवक परिवेश रोड़ा

आने वाले एचडीआर रंग बफर

... और इस दृश्य में कोहरे की छाया को लागू करने का परिणाम इस तरह दिखता है:

कोहरे को लागू करने के बाद एचडीआर बनावट।

दुनिया में स्थिति को फिर से बनाने के लिए गहराई बफर का उपयोग किया जाता है। यह Witcher 3 शेड्स के लिए मानक पैटर्न है।

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

यदि पिक्सेल पिक्सेल आकाश में है, तो यह निर्धारित करके एक शेडर शुरू होता है। यदि पिक्सेल आकाश में होता है (गहराई == 1.0), तो शेड काला हो जाता है। यदि पिक्सेल दृश्य में है (गहराई <1.0), तो हम गहराई बफर (लाइनों 7-11) का उपयोग करके दुनिया में स्थिति को फिर से बनाते हैं और कोहरे की गणना करना जारी रखते हैं।

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

पहली बात आपको "द विचर 3" में कोहरे के बारे में जानना होगा: इसमें दो भाग होते हैं - "कोहरे का रंग" और "वातावरण का रंग"।

 struct FogResult  
 {  
    float4 paramsFog;     // RGB: color, A: influence  
    float4 paramsAerial;  // RGB: color, A: influence  
 };

प्रत्येक भाग के लिए तीन रंग हैं: सामने, मध्य और पीछे। अर्थात्, निरंतर बफर में "FogColorFront", "FogColorMiddle", "AerialColorBack", आदि जैसे डेटा हैं ... आइए आने वाले डेटा को देखें:

   // *** Inputs *** //  
   float3 FogSunDir = cb12_v38.xyz;  
   float3 FogColorFront = cb12_v39.xyz;  
   float3 FogColorMiddle = cb12_v40.xyz;  
   float3 FogColorBack = cb12_v41.xyz;  
     
   float4 FogBaseParams = cb12_v42;  
   float4 FogDensityParamsScene = cb12_v43;  
   float4 FogDensityParamsSky = cb12_v44;  
     
   float3 AerialColorFront = cb12_v45.xyz;  
   float3 AerialColorMiddle = cb12_v46.xyz;  
   float3 AerialColorBack = cb12_v47.xyz;  
   float4 AerialParams = cb12_v48;

अंतिम रंगों की गणना करने से पहले, हमें वैक्टर और स्केलर उत्पादों की गणना करने की आवश्यकता है। Shader की दुनिया में पिक्सेल स्थिति, कैमरा स्थिति (cb12 [0] .xyz) और कोहरे / प्रकाश दिशा (cb12 [38] .xyz) तक पहुंच है। यह हमें कोहरे के रूप और दिशा के वेक्टर के स्केलर उत्पाद की गणना करने की अनुमति देता है।

   float3 frag_vec = fragPosWorldSpace.xyz - customCameraPos.xyz;  
   float frag_dist = length(frag_vec);  
     
   float3 frag_dir = frag_vec / frag_dist;  
   
   float dot_fragDirSunDir = dot(GlobalLightDirection.xyz, frag_dir);

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

   float3 curr_col_fog;  
   float3 curr_col_aerial;  
   {  
     float _dot = dot_fragDirSunDir;  
   
     float _dd = _dot;  
     {  
       const float _distOffset = -150;  
       const float _distRange = 500;  
       const float _mul = 1.0 / _distRange;  
       const float _bias = _distOffset * _mul;  
   
       _dd = abs(_dd);  
       _dd *= _dd;  
       _dd *= saturate( frag_dist * _mul + _bias );  
     }  
   
     curr_col_fog = lerp( FogColorMiddle.xyz, (_dot>0.0f ? FogColorFront.xyz : FogColorBack.xyz), _dd );  
     curr_col_aerial = lerp( AerialColorMiddle.xyz, (_dot>0.0f ? AerialColorFront.xyz : AerialColorBack.xyz), _dd );  
   }

यह कोड ब्लॉक हमें यह स्पष्ट करता है कि ये 0.002 और -0.300 कहां से आए हैं। जैसा कि हम देख सकते हैं, दृश्य और प्रकाश व्यवस्था के बीच स्केलर उत्पाद "फ्रंट" और "बैक" रंगों के बीच चुनाव के लिए जिम्मेदार है। चतुर!

यहाँ परिणामी अंतिम ढाल (_dd) का एक दृश्य है।

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

एक वेक्टर [कैमरा ---> दुनिया] होने पर, हम इसके सभी घटकों को 16 में विभाजित कर सकते हैं - यह एक प्रारूपण चरण होगा। जैसा कि हम नीचे देखते हैं, गणना में केवल .z (ऊंचाई) घटक ( cur_pos_z_step ) शामिल है ।

कोहरे raymarching द्वारा कार्यान्वित, उदाहरण के लिए के बारे में और अधिक पढ़ें, यहाँ ।

   float fog_amount = 1;  
   float fog_amount_scale = 0;  
   [branch]  
   if ( frag_dist >= AerialParams.y )  
   {  
     float curr_pos_z_base = (customCameraPos.z + FogBaseParams.y) * density_factor;  
     float curr_pos_z_step = frag_step.z * density_factor;  
   
     [unroll]  
     for ( int i=16; i>0; --i )  
     {  
       fog_amount *= 1 - saturate( density_sample_scale / (1 + max( 0.0, curr_pos_z_base + (i) * curr_pos_z_step ) ) );  
     }  
   
     fog_amount = 1 - fog_amount;  
     fog_amount_scale = saturate( (frag_dist - AerialParams.y) * AerialParams.z );  
   }  
   
   FogResult ret;  
   
   ret.paramsFog = float4 ( curr_col_fog, fog_amount_scale * pow( abs(fog_amount), final_exp_fog ) );  
   ret.paramsAerial = float4 ( curr_col_aerial, fog_amount_scale * pow( abs(fog_amount), final_exp_aerial ) );

कोहरे की मात्रा स्पष्ट रूप से ऊंचाई (घटकों .z) पर निर्भर करती है, अंत में कोहरे की मात्रा कोहरे / वायुमंडल की डिग्री तक बढ़ा दी जाती है।

final_exp_fog और final_exp_aerial को निरंतर बफर से लिया जाता है; वे आपको नियंत्रित करने की अनुमति देते हैं कि कोहरे और वातावरण के रंग दुनिया को बढ़ती ऊंचाई के साथ कैसे प्रभावित करते हैं।

कोहरा छा गया

मुझे जो छायादार मिला, उसमें निम्नलिखित विधानसभा कोड नहीं था:

  109:  mad_sat r1.xy, r0.wwww, cb12[189].xzxx, cb12[189].ywyy  
  110:  add r5.xyz, -r3.xyzx, cb12[188].xyzx  
  111:  mad r5.xyz, r1.xxxx, r5.xyzx, r3.xyzx  
  112:  add r0.z, l(-1.000000), cb12[188].w  
  113:  mad r0.z, r1.y, r0.z, l(1.000000)  
  114:  mul_sat r5.w, r0.w, r0.z  
  115:  lt r0.z, l(0.000000), cb12[192].x  
  116:  if_nz r0.z  
  117:   mad_sat r1.xy, r0.wwww, cb12[191].xzxx, cb12[191].ywyy  
  118:   add r6.xyz, -r3.xyzx, cb12[190].xyzx  
  119:   mad r3.xyz, r1.xxxx, r6.xyzx, r3.xyzx  
  120:   add r0.z, l(-1.000000), cb12[190].w  
  121:   mad r0.z, r1.y, r0.z, l(1.000000)  
  122:   mul_sat r3.w, r0.w, r0.z  
  123:   add r1.xyzw, -r5.xyzw, r3.xyzw  
  124:   mad r5.xyzw, cb12[192].xxxx, r1.xyzw, r5.xyzw  
  125:  endif

जिसे मैं समझने में सक्षम था, उसे देखते हुए, यह रंग और कोहरे के प्रभाव को

फिर से परिभाषित करने जैसा है : अधिकांश समय, केवल एक पुनर्परिभाषित किया जाता है (cb12_v192.x 0.0), लेकिन इस विशेष मामले में इसका मान ~ 0.22 है, इसलिए हम दूसरा ओवरराइड करते हैं।

 #ifdef OVERRIDE_FOG  
     
   // Override  
   float fog_influence = ret.paramsFog.w; // r0.w  
   
   float override1ColorScale = cb12_v189.x;  
   float override1ColorBias = cb12_v189.y;  
   float3 override1Color = cb12_v188.rgb;  
     
   float override1InfluenceScale = cb12_v189.z;  
   float override1InfluenceBias = cb12_v189.w;  
   float override1Influence = cb12_v188.w;  
     
   float override1ColorAmount = saturate(fog_influence * override1ColorScale + override1ColorBias);  
   float override1InfluenceAmount = saturate(fog_influence * override1InfluenceScale + override1InfluenceBias);    
     

   float4 paramsFogOverride;  
   paramsFogOverride.rgb = lerp(curr_col_fog, override1Color, override1ColorAmount ); // ***r5.xyz   
     
   float param1 = lerp(1.0, override1Influence, override1InfluenceAmount); // r0.x  
   paramsFogOverride.w = saturate(param1 * fog_influence ); // ** r5.w  
   
     
   const float extraFogOverride = cb12_v192.x;  
     
   [branch]   
   if (extraFogOverride > 0.0)  
   {  
     float override2ColorScale = cb12_v191.x;  
     float override2ColorBias = cb12_v191.y;  
     float3 override2Color = cb12_v190.rgb;  
     
     float override2InfluenceScale = cb12_v191.z;  
     float override2InfluenceBias = cb12_v191.w;  
     float override2Influence = cb12_v190.w;  
       
     float override2ColorAmount = saturate(fog_influence * override2ColorScale + override2ColorBias);  
     float override2InfluenceAmount = saturate(fog_influence * override2InfluenceScale + override2InfluenceBias);  
      

     float4 paramsFogOverride2;  
     paramsFogOverride2.rgb = lerp(curr_col_fog, override2Color, override2ColorAmount); // r3.xyz   
           
     float ov_param1 = lerp(1.0, override2Influence, override2InfluenceAmount); // r0.z  
     paramsFogOverride2.w = saturate(ov_param1 * fog_influence); // r3.w  
   
     paramsFogOverride = lerp(paramsFogOverride, paramsFogOverride2, extraFogOverride);  
   
   }  
   ret.paramsFog = paramsFogOverride;  
     
 #endif

यहाँ एक रेडिफिनिशन (दूसरी छवि) और डबल रिडिफाइनमेंट (तीसरी छवि, अंतिम परिणाम) के साथ कोहरे (पहली छवि) को फिर से परिभाषित किए बिना हमारी तैयार कीमत है:

परिवेश रोड़ा का विनियमन

मुझे जो छायादार मिला, उसमें परिवेशगत रोड़ा का उपयोग नहीं किया गया था। आइए फिर से AO की बनावट और उस कोड को देखें जो हमें रुचता है:

  13:  ld_indexable(texture2d)(float,float,float,float) r0.x, r0.xyzw, t2.xyzw  
  14:  max r0.x, r0.x, cb3[1].x  
  15:  add r0.yzw, r1.xxyz, -cb12[0].xxyz  
  16:  dp3 r1.x, r0.yzwy, r0.yzwy  
  17:  sqrt r1.x, r1.x  
  18:  add r1.y, r1.x, -cb3[0].x  
  19:  add r1.zw, -cb3[0].xxxz, cb3[0].yyyw  
  20:  div_sat r1.y, r1.y, r1.z  
  21:  mad r1.y, r1.y, r1.w, cb3[0].z  
  22:  add r0.x, r0.x, l(-1.000000)  
  23:  mad r0.x, r1.y, r0.x, l(1.000000)

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

हम बनावट से एओ को लोड करके शुरू करते हैं, फिर अधिकतम निर्देश को निष्पादित करते हैं। इस दृश्य में, cb3_v1.x बहुत अधिक (0.96888) है, जो AO को बहुत कमजोर बनाता है।

कोड का अगला भाग दुनिया में कैमरे और पिक्सेल की स्थिति के बीच की दूरी की गणना करता है।

मेरा मानना है कि कोड कभी-कभी खुद के लिए बोलता है, तो आइए एचएलएसएल को देखें, जो इस सेटअप के थोक काम करता है:

 float AdjustAmbientOcclusion(in float inputAO, in float worldToCameraDistance)  
 {  
   // *** Inputs *** //  
   const float aoDistanceStart = cb3_v0.x;  
   const float aoDistanceEnd = cb3_v0.y;  
   const float aoStrengthStart = cb3_v0.z;  
   const float aoStrengthEnd = cb3_v0.w;  
      
   // * Adjust AO  
   float aoDistanceIntensity = linstep( aoDistanceStart, aoDistanceEnd, worldToCameraDistance );  
   float aoStrength = lerp(aoStrengthStart, aoStrengthEnd, aoDistanceIntensity);   
   float adjustedAO = lerp(1.0, inputAO, aoStrength);  
     
   return adjustedAO;   
 }

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

जैसा कि आप देख सकते हैं, निरंतर बफर में हमारे पास एओ स्टार्ट / एंड डिस्टेंस वैल्यू है। लिनस्टेप का आउटपुट एओ की ताकत (और साथ ही सीबीएफ़र से) को प्रभावित करता है, और ताकत एओ के आउटपुट को प्रभावित करता है।

एक संक्षिप्त उदाहरण: पिक्सेल दूर है, उदाहरण के लिए, दूरी 500 है।

लिनस्टेप 1.0 रिटर्न;
anoStrength बराबर aoStrengthEnd के बराबर है;

यह एओ रिटर्न में परिणाम देता है, जो इनपुट मूल्य का लगभग 77% (अंतिम बल) है।

इस फ़ंक्शन के लिए आने वाली AO को पहले अधिकतम ऑपरेशन के अधीन किया गया था।

यह सब एक साथ डालें

कोहरे के रंग और वातावरण के रंग के लिए रंग और प्रभाव प्राप्त करने के बाद, आप अंत में उन्हें जोड़ सकते हैं।

हम परिणामस्वरूप एओ के साथ प्रभाव को ध्यान में रखते हुए शुरू करते हैं:

   ...
   FogResult fog = CalculateFog( worldPos, CameraPosition, fogStart, ao, false );  
      
   // Apply AO to influence  
   fog.paramsFog.w *= ao;  
   fog.paramsAerial.w *= ao; 
      
   // Mix fog with scene color  
   outColor = ApplyFog(fog, colorHDR);

सभी जादू ApplyFog फ़ंक्शन में होता है :

 float3 ApplyFog(FogResult fog, float3 color)  
 {  
   const float3 LuminanceFactors = float3(0.333f, 0.555f, 0.222f);  
   
   float3 aerialColor = dot(LuminanceFactors, color) * fog.paramsAerial.xyz;  
   color = lerp(color, aerialColor, fog.paramsAerial.w);  
   color = lerp(color, fog.paramsFog.xyz, fog.paramsFog.w);  
    
   return color.xyz;  
 }

सबसे पहले, हम पिक्सेल की चमक की गणना करते हैं:

फिर हम इसे वायुमंडल के रंग से गुणा करते हैं:

फिर हम एचडीआर रंग को वायुमंडल के रंग के साथ जोड़ते हैं:

अंतिम चरण कोहरे के रंग के साथ मध्यवर्ती परिणाम को संयोजित करना है:

बस इतना ही!

कुछ डिबगिंग स्क्रीनशॉट

वायुमंडलीय प्रभाव

वायुमंडल का रंग

कोहरे का असर

कोहरे का रंग

कोहरे के बिना दृश्य समाप्त

कोहरे के साथ तैयार दृश्य

समाप्त दृश्य सिर्फ मुख्य कोहरा है

तुलना की आसानी के लिए सभी कोहरे के साथ फिर से तैयार दृश्य

संपूर्ण

मुझे लगता है कि आप उपरोक्त बहुत कुछ समझ सकते हैं, यदि आप शैडर को देखते हैं, तो यह यहां है ।

मैं खुशी के साथ कह सकता हूं कि यह शेडर बिल्कुल मूल के समान है - यह मुझे बहुत खुश करता है।

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

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

मुझे आपको याद दिलाना है - इस shader में से अधिकांश मेरे द्वारा निर्मित / विश्लेषण नहीं किया गया था। सभी पावती सीडी PROJEKT RED को भेजी जानी चाहिए। उनका समर्थन करें, वे एक उत्कृष्ट काम करते हैं।

भाग 3. शूटिंग सितारे

"द विचर 3" में एक छोटा लेकिन जिज्ञासु विवरण है - शूटिंग सितारे। दिलचस्प है, वे रक्त और शराब डीएलसी में नहीं लगते हैं।

वीडियो में आप देख सकते हैं कि वे कैसे दिखते हैं:

आइए देखें कि हम इस प्रभाव को पाने में कैसे कामयाब रहे।

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

हमारा एजेंडा काफी परिचित है: पहले मैं सामान्य गुणों का वर्णन करूंगा, फिर मैं ज्यामिति से संबंधित विषयों के बारे में बात करूंगा, और अंत में हम पिक्सेल shader की ओर बढ़ेंगे, जहां सबसे दिलचस्प चीजें हो रही हैं।

1. सामान्य अवलोकन

संक्षेप में वर्णन करें कि क्या हो रहा है।

आकाश, आकाश और चंद्रमा के गुंबद के तुरंत बाद शूटिंग सितारों को एक सक्रिय मार्ग में खींचा जाता है:

DrawIndexed (720) - आकाश के गुंबद,
DrawIndexed (2160) - आकाश / चंद्रमा के लिए क्षेत्र,
DrawIndexed (36) - अप्रासंगिक है, सूरज की रोड़ा की एक समानांतर खात की तरह दिखता है (?)
DrawIndexed (12) - शूटिंग स्टार
DrawIndexedInstanced (1116, 1) - सिरस बादल

की तरह सिरस बादल , प्रत्येक शूटिंग स्टार लगातार दो बार ली गई है।

पहले ड्रॉ कॉल से पहले

पहले ड्रॉ कॉल का परिणाम

इस गेम के प्रीमेप्टिव पास के कई तत्वों के अलावा, दूसरे ड्रॉ कॉल का परिणाम निम्न मिक्सिंग स्टेट का उपयोग किया जाता है:

2. ज्यामिति

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

एक शूटिंग स्टार का अनुमानित क्वाड।

करीब भी एक शूटिंग स्टार का अनुमानित क्वाड है। आप दो त्रिकोणों को दर्शाने वाली रेखा के वायरफ्रेम प्रदर्शन को देख सकते हैं।

एक मिनट रुको, लेकिन वहाँ है DrawIndexed (12) ! क्या इसका मतलब यह है कि हम एक ही समय में दो शूटिंग सितारों को आकर्षित करते हैं?

हाँ।

इस फ्रेम में, शूटिंग सितारों में से एक पूरी तरह से दृश्यता के पिरामिड के बाहर है।

आइए देखें कोडर के कोड के लिए शीर्ष shader:

 vs_5_0  
    dcl_globalFlags refactoringAllowed  
    dcl_constantbuffer cb1[9], immediateIndexed  
    dcl_constantbuffer cb2[3], immediateIndexed  
    dcl_constantbuffer cb12[193], immediateIndexed  
    dcl_input v0.xyz  
    dcl_input v1.xyzw  
    dcl_input v2.xy  
    dcl_input v3.xy  
    dcl_input v4.xy  
    dcl_input v5.xyz  
    dcl_input v6.x  
    dcl_input v7.x  
    dcl_output o0.xyzw  
    dcl_output o1.xyzw  
    dcl_output o2.xy  
    dcl_output o3.xyzw  
    dcl_output_siv o4.xyzw, position  
    dcl_temps 5  
   0: mov r0.xyz, v0.xyzx  
   1: mov r0.w, l(1.000000)  
   2: dp4 r1.x, r0.xyzw, cb2[0].xyzw  
   3: dp4 r1.y, r0.xyzw, cb2[1].xyzw  
   4: dp4 r1.z, r0.xyzw, cb2[2].xyzw  
   5: add r0.x, v2.x, v2.y  
   6: add r0.y, -v2.y, v2.x  
   7: add r2.xyz, -r1.zxyz, cb1[8].zxyz  
   8: dp3 r0.z, r2.xyzx, r2.xyzx  
   9: rsq r0.z, r0.z  
  10: mul r2.xyz, r0.zzzz, r2.xyzx  
  11: dp3 r0.z, v5.xyzx, v5.xyzx  
  12: rsq r0.z, r0.z  
  13: mul r3.xyz, r0.zzzz, v5.xyzx  
  14: mul r4.xyz, r2.xyzx, r3.yzxy  
  15: mad r2.xyz, r2.zxyz, r3.zxyz, -r4.xyzx  
  16: dp3 r0.z, r2.xyzx, r2.xyzx  
  17: rsq r0.z, r0.z  
  18: mul r2.xyz, r0.zzzz, r2.xyzx  
  19: mad r0.z, v7.x, v6.x, l(1.000000)  
  20: mul r3.xyz, r0.zzzz, r3.xyzx  
  21: mul r3.xyz, r3.xyzx, v3.xxxx  
  22: mul r2.xyz, r2.xyzx, v3.yyyy  
  23: mad r0.xzw, r3.xxyz, r0.xxxx, r1.xxyz  
  24: mad r0.xyz, r2.xyzx, r0.yyyy, r0.xzwx  
  25: mov r0.w, l(1.000000)  
  26: dp4 o4.x, r0.xyzw, cb1[0].xyzw  
  27: dp4 o4.y, r0.xyzw, cb1[1].xyzw  
  28: dp4 o4.z, r0.xyzw, cb1[2].xyzw  
  29: dp4 o4.w, r0.xyzw, cb1[3].xyzw  
  30: add r0.xyz, r0.xyzx, -cb12[0].xyzx  
  31: dp3 r0.w, r0.xyzx, r0.xyzx  
  32: sqrt r0.w, r0.w  
  33: div r0.xyz, r0.xyzx, r0.wwww  
  34: add r0.w, r0.w, -cb12[22].z  
  35: max r0.w, r0.w, l(0)  
  36: min r0.w, r0.w, cb12[42].z  
  37: dp3 r0.x, cb12[38].xyzx, r0.xyzx  
  38: mul r0.y, abs(r0.x), abs(r0.x)  
  39: mad_sat r1.x, r0.w, l(0.002000), l(-0.300000)  
  40: mul r0.y, r0.y, r1.x  
  41: lt r1.x, l(0), r0.x  
  42: movc r1.yzw, r1.xxxx, cb12[39].xxyz, cb12[41].xxyz  
  43: add r1.yzw, r1.yyzw, -cb12[40].xxyz  
  44: mad r1.yzw, r0.yyyy, r1.yyzw, cb12[40].xxyz  
  45: movc r2.xyz, r1.xxxx, cb12[45].xyzx, cb12[47].xyzx  
  46: add r2.xyz, r2.xyzx, -cb12[46].xyzx  
  47: mad o0.xyz, r0.yyyy, r2.xyzx, cb12[46].xyzx  
  48: ge r0.y, r0.w, cb12[48].y  
  49: if_nz r0.y  
  50:  mad r0.y, r0.z, cb12[22].z, cb12[0].z  
  51:  mul r0.z, r0.w, r0.z  
  52:  mul r0.z, r0.z, l(0.062500)  
  53:  mul r1.x, r0.w, cb12[43].x  
  54:  mul r1.x, r1.x, l(0.062500)  
  55:  add r0.x, r0.x, cb12[42].x  
  56:  add r2.x, cb12[42].x, l(1.000000)  
  57:  div_sat r0.x, r0.x, r2.x  
  58:  add r2.x, -cb12[43].z, cb12[43].y  
  59:  mad r0.x, r0.x, r2.x, cb12[43].z  
  60:  add r0.y, r0.y, cb12[42].y  
  61:  mul r2.x, r0.x, r0.y  
  62:  mul r0.z, r0.x, r0.z  
  63:  mad r3.xyzw, r0.zzzz, l(16.000000, 15.000000, 14.000000, 13.000000), r2.xxxx  
  64:  max r3.xyzw, r3.xyzw, l(0, 0, 0, 0)  
  65:  add r3.xyzw, r3.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000)  
  66:  div_sat r3.xyzw, r1.xxxx, r3.xyzw  
  67:  add r3.xyzw, -r3.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000)  
  68:  mul r2.y, r3.y, r3.x  
  69:  mul r2.y, r3.z, r2.y  
  70:  mul r2.y, r3.w, r2.y  
  71:  mad r3.xyzw, r0.zzzz, l(12.000000, 11.000000, 10.000000, 9.000000), r2.xxxx  
  72:  max r3.xyzw, r3.xyzw, l(0, 0, 0, 0)  
  73:  add r3.xyzw, r3.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000)  
  74:  div_sat r3.xyzw, r1.xxxx, r3.xyzw  
  75:  add r3.xyzw, -r3.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000)  
  76:  mul r2.y, r2.y, r3.x  
  77:  mul r2.y, r3.y, r2.y  
  78:  mul r2.y, r3.z, r2.y  
  79:  mul r2.y, r3.w, r2.y  
  80:  mad r3.xyzw, r0.zzzz, l(8.000000, 7.000000, 6.000000, 5.000000), r2.xxxx  
  81:  max r3.xyzw, r3.xyzw, l(0, 0, 0, 0)  
  82:  add r3.xyzw, r3.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000)  
  83:  div_sat r3.xyzw, r1.xxxx, r3.xyzw  
  84:  add r3.xyzw, -r3.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000)  
  85:  mul r2.y, r2.y, r3.x  
  86:  mul r2.y, r3.y, r2.y  
  87:  mul r2.y, r3.z, r2.y  
  88:  mul r2.y, r3.w, r2.y  
  89:  mad r2.zw, r0.zzzz, l(0.000000, 0.000000, 4.000000, 3.000000), r2.xxxx  
  90:  max r2.zw, r2.zzzw, l(0, 0, 0, 0)  
  91:  add r2.zw, r2.zzzw, l(0.000000, 0.000000, 1.000000, 1.000000)  
  92:  div_sat r2.zw, r1.xxxx, r2.zzzw  
  93:  add r2.zw, -r2.zzzw, l(0.000000, 0.000000, 1.000000, 1.000000)  
  94:  mul r2.y, r2.z, r2.y  
  95:  mul r2.y, r2.w, r2.y  
  96:  mad r2.x, r0.z, l(2.000000), r2.x  
  97:  max r2.x, r2.x, l(0)  
  98:  add r2.x, r2.x, l(1.000000)  
  99:  div_sat r2.x, r1.x, r2.x  
  100:  add r2.x, -r2.x, l(1.000000)  
  101:  mul r2.x, r2.x, r2.y  
  102:  mad r0.x, r0.y, r0.x, r0.z  
  103:  max r0.x, r0.x, l(0)  
  104:  add r0.x, r0.x, l(1.000000)  
  105:  div_sat r0.x, r1.x, r0.x  
  106:  add r0.x, -r0.x, l(1.000000)  
  107:  mad r0.x, -r2.x, r0.x, l(1.000000)  
  108:  add r0.y, r0.w, -cb12[48].y  
  109:  mul_sat r0.y, r0.y, cb12[48].z  
  110: else  
  111:  mov r0.xy, l(1.000000, 0.000000, 0.000000, 0.000000)  
  112: endif  
  113: log r0.x, r0.x  
  114: mul r0.z, r0.x, cb12[42].w  
  115: exp r0.z, r0.z  
  116: mul r0.z, r0.z, r0.y  
  117: mul r0.x, r0.x, cb12[48].x  
  118: exp r0.x, r0.x  
  119: mul o0.w, r0.x, r0.y  
  120: mad_sat r0.xy, r0.zzzz, cb12[189].xzxx, cb12[189].ywyy  
  121: add r2.xyz, -r1.yzwy, cb12[188].xyzx  
  122: mad r2.xyz, r0.xxxx, r2.xyzx, r1.yzwy  
  123: add r0.x, cb12[188].w, l(-1.000000)  
  124: mad r0.x, r0.y, r0.x, l(1.000000)  
  125: mul_sat r2.w, r0.x, r0.z  
  126: lt r0.x, l(0), cb12[192].x  
  127: if_nz r0.x  
  128:  mad_sat r0.xy, r0.zzzz, cb12[191].xzxx, cb12[191].ywyy  
  129:  add r3.xyz, -r1.yzwy, cb12[190].xyzx  
  130:  mad r1.xyz, r0.xxxx, r3.xyzx, r1.yzwy  
  131:  add r0.x, cb12[190].w, l(-1.000000)  
  132:  mad r0.x, r0.y, r0.x, l(1.000000)  
  133:  mul_sat r1.w, r0.x, r0.z  
  134:  add r0.xyzw, -r2.xyzw, r1.xyzw  
  135:  mad o1.xyzw, cb12[192].xxxx, r0.xyzw, r2.xyzw  
  136: else  
  137:  mov o1.xyzw, r2.xyzw  
  138: endif  
  139: mov o3.xyzw, v1.xyzw  
  140: mov o2.xy, v4.yxyy  
  141: ret

यहां, कोहरे की गणना तुरंत ध्यान आकर्षित कर सकती है (लाइनें 30-138)। कोहरे के शीर्ष की गणना प्रदर्शन कारणों से समझ में आता है। इसके अलावा, हमें कोहरे की इतनी सटीकता की आवश्यकता नहीं है - उल्कापिंड आमतौर पर गेराल्ट के सिर पर उड़ते हैं और क्षितिज तक नहीं पहुंचते हैं।

वायुमंडलीय मापदंडों (आरजीबी = रंग, एक = प्रभाव) को o0.xyzw में और कोहरे के मापदंडों को o1.xyzw में संग्रहीत किया जाता है।

o2.xy (लाइन 140) सिर्फ टेक्सकोर्ड्स है।
o3.xyzw (लाइन 139) अप्रासंगिक है।

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

पहला डेटा स्थिति है:

जैसा कि ऊपर उल्लेख किया गया है, यहां हमारे पास 2 क्वाड-ए: 8 कोने, 12 सूचक हैं।

लेकिन हर क्वाड के लिए पोजिशन समान क्यों है? काफी सरल - यह क्वाड के केंद्र की स्थिति है।

इसके अलावा, प्रत्येक शीर्ष केंद्र से केंद्र के किनारे तक एक ऑफसेट है:

इसका मतलब है कि हर शूटिंग स्टार के पास विश्व अंतरिक्ष में (400, 3) इकाइयों का आकार है। (XY प्लेन में, Witcher 3 में, Z अक्ष को निर्देशित किया गया है)

अंतिम तत्व जो प्रत्येक शीर्ष पर है, विश्व अंतरिक्ष में एक यूनिट दिशा वेक्टर है जो एक शूटिंग स्टार की गति को नियंत्रित करता है:

चूंकि डेटा सीपीयू से आता है, यह समझना मुश्किल है कि इसकी गणना कैसे की जाती है।

अब हम बिलबोर्डिंग कोड पर चलते हैं। यह विचार काफी सरल है - पहले आपको क्वाड के केंद्र से कैमरे तक एक यूनिट वेक्टर मिलता है:

   7: add r2.xyz, -r1.zxyz, cb1[8].zxyz  
   8: dp3 r0.z, r2.xyzx, r2.xyzx  
   9: rsq r0.z, r0.z  
  10: mul r2.xyz, r0.zzzz, r2.xyzx

तब हमें एक एकल स्पर्शरेखा वेक्टर मिलता है जो शूटिंग स्टार की गति को नियंत्रित करता है।

यह देखते हुए कि यह वेक्टर सीपीयू की तरफ पहले से ही सामान्यीकृत है, यह सामान्यीकरण निरर्थक है।

  11: dp3 r0.z, v5.xyzx, v5.xyzx  
  12: rsq r0.z, r0.z  
  13: mul r3.xyz, r0.zzzz, v5.xyzx

यदि दो वैक्टर हैं, तो आने वाले वैक्टरों के लिए द्वि-स्पर्शरेखा वेक्टर लंब को निर्धारित करने के लिए एक वेक्टर उत्पाद का उपयोग किया जाता है।

  14: mul r4.xyz, r2.xyzx, r3.yzxy  
  15: mad r2.xyz, r2.zxyz, r3.zxyz, -r4.xyzx  
  16: dp3 r0.z, r2.xyzx, r2.xyzx  
  17: rsq r0.z, r0.z  
  18: mul r2.xyz, r0.zzzz, r2.xyzx

अब हमारे पास सामान्यीकृत वैक्टर स्पर्शरेखा (r3.xyz) और बिटेंगेंट (r2.xyz) हैं।

आइए आने वाले तत्व TEXCOORD1 के अनुरूप Xsize और Ysize पेश करें , इसलिए उदाहरण के लिए (-200, 1.50)।

विश्व अंतरिक्ष में स्थिति की अंतिम गणना निम्नानुसार की जाती है:

  19: mad r0.z, v7.x, v6.x, l(1.000000)  
  20: mul r3.xyz, r0.zzzz, r3.xyzx  
  21: mul r3.xyz, r3.xyzx, v3.xxxx  
  22: mul r2.xyz, r2.xyzx, v3.yyyy  
  23: mad r0.xzw, r3.xxyz, r0.xxxx, r1.xxyz  
  24: mad r0.xyz, r2.xyzx, r0.yyyy, r0.xzwx  
  25: mov r0.w, l(1.000000)

यह देखते हुए कि r0.x, r0.y और r0.z 1.0 के बराबर हैं, अंतिम गणना सरल है:

worldSpacePosition = quadCenter + tangent * Xsize + bitangent * Ysize

अंतिम भाग SV_Position प्राप्त करने के लिए एक दृश्य-प्रक्षेपण मैट्रिक्स द्वारा विश्व अंतरिक्ष में एक स्थिति का एक सरल गुणन है:

  26: dp4 o4.x, r0.xyzw, cb1[0].xyzw  
  27: dp4 o4.y, r0.xyzw, cb1[1].xyzw  
  28: dp4 o4.z, r0.xyzw, cb1[2].xyzw  
  29: dp4 o4.w, r0.xyzw, cb1[3].xyzw

3. पिक्सेल शेडर

जैसा कि सामान्य अवलोकन अनुभाग में कहा गया है, निम्नलिखित सम्मिश्रण अवस्था का उपयोग किया जाता है: जहाँ SrcColor और SrcAlpha क्रमशः पिक्सेल shader से .rgb और .a घटक होते हैं , और DestColor .rgb रंग वर्तमान में रेंडरर्ट में है। पारदर्शिता को नियंत्रित करने वाला मुख्य संकेतक SrcAlpha है । कई प्रोएक्टिव गेम शेडर्स इसे अपारदर्शिता के रूप में परिकलित करते हैं और अंत में इसे इस प्रकार लागू करते हैं: गिरने वाले स्टार शेडर कोई अपवाद नहीं थे। इस पैटर्न के बाद, हम तीन मामलों पर विचार करते हैं जिसमें अपारदर्शिता 1.0, 0.1 और 0.0 है।

FinalColor = SrcColor * One + DestColor * (1.0 - SrcAlpha) =
FinalColor = SrcColor + DestColor * (1.0 - SrcAlpha)

return float4( color * opacity, opacity )

a) opacity = 1.0

FinalColor = color * opacity + DestColor * (1.0 - opacity) =
FinalColor = color = SrcColor

b) opacity = 0.1

FinalColor = color * opacity + DestColor * (1.0 - opacity) =
FinalColor = 0.1 * color + 0.9 * DestColor

c) opacity = 0.0

FinalColor = color * opacity + DestColor * (1.0 - opacity) =
FinalColor = DestColor

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

जब हम पिक्सेल shader के कोडांतरक को समझने लगते हैं, तो यह स्पष्ट हो जाता है:

 ps_5_0  
    dcl_globalFlags refactoringAllowed  
    dcl_constantbuffer cb0[10], immediateIndexed  
    dcl_constantbuffer cb2[3], immediateIndexed  
    dcl_constantbuffer cb4[2], immediateIndexed  
    dcl_input_ps linear v0.xyzw  
    dcl_input_ps linear v1.xyzw  
    dcl_input_ps linear v2.y  
    dcl_input_ps linear v3.w  
    dcl_output o0.xyzw  
    dcl_temps 4  
   0: mov_sat r0.x, v2.y  
   1: ge r0.y, r0.x, l(0.052579)  
   2: ge r0.z, l(0.965679), r0.x  
   3: and r0.y, r0.z, r0.y  
   4: if_nz r0.y  
   5:  ge r0.y, l(0.878136), r0.x  
   6:  add r0.z, r0.x, l(-0.052579)  
   7:  mul r1.w, r0.z, l(1.211303)  
   8:  mov_sat r0.z, r1.w  
   9:  mad r0.w, r0.z, l(-2.000000), l(3.000000)  
  10:  mul r0.z, r0.z, r0.z  
  11:  mul r0.z, r0.z, r0.w  
  12:  mul r2.x, r0.z, l(0.084642)  
  13:  mov r1.yz, l(0.000000, 0.000000, 0.084642, 0.000000)  
  14:  movc r2.yzw, r0.yyyy, r1.yyzw, l(0.000000, 0.000000, 0.000000, 0.500000)  
  15:  not r0.z, r0.y  
  16:  if_z r0.y  
  17:   ge r0.y, l(0.924339), r0.x  
  18:   add r0.w, r0.x, l(-0.878136)  
  19:   mul r1.w, r0.w, l(21.643608)  
  20:   mov_sat r0.w, r1.w  
  21:   mad r3.x, r0.w, l(-2.000000), l(3.000000)  
  22:   mul r0.w, r0.w, r0.w  
  23:   mul r0.w, r0.w, r3.x  
  24:   mad r1.x, r0.w, l(0.889658), l(0.084642)  
  25:   mov r1.yz, l(0.000000, 0.084642, 0.974300, 0.000000)  
  26:   movc r2.xyzw, r0.yyyy, r1.xyzw, r2.xyzw  
  27:  else  
  28:   mov r2.y, l(0)  
  29:   mov r0.y, l(-1)  
  30:  endif  
  31:  not r0.w, r0.y  
  32:  and r0.z, r0.w, r0.z  
  33:  if_nz r0.z  
  34:   ge r0.y, r0.x, l(0.924339)  
  35:   add r0.x, r0.x, l(-0.924339)  
  36:   mul r1.w, r0.x, l(24.189651)  
  37:   mov_sat r0.x, r1.w  
  38:   mad r0.z, r0.x, l(-2.000000), l(3.000000)  
  39:   mul r0.x, r0.x, r0.x  
  40:   mul r0.x, r0.x, r0.z  
  41:   mad r1.x, r0.x, l(-0.974300), l(0.974300)  
  42:   mov r1.yz, l(0.000000, 0.974300, 0.000000, 0.000000)  
  43:   movc r2.xyzw, r0.yyyy, r1.xyzw, r2.xyzw  
  44:  endif  
  45: else  
  46:  mov r2.yzw, l(0.000000, 0.000000, 0.000000, 0.500000)  
  47:  mov r0.y, l(0)  
  48: endif  
  49: mov_sat r2.w, r2.w  
  50: mad r0.x, r2.w, l(-2.000000), l(3.000000)  
  51: mul r0.z, r2.w, r2.w  
  52: mul r0.x, r0.z, r0.x  
  53: add r0.z, -r2.y, r2.z  
  54: mad r0.x, r0.x, r0.z, r2.y  
  55: movc r0.x, r0.y, r2.x, r0.x  
  56: mad r0.y, cb4[1].x, -cb0[9].w, l(1.000000)  
  57: mul_sat r0.y, r0.y, v3.w  
  58: mul r0.x, r0.y, r0.x  
  59: mul r0.yzw, cb2[2].xxyz, cb4[0].xxxx  
  60: mul r0.x, r0.x, cb2[2].w  
  61: dp3 r1.x, l(0.333000, 0.555000, 0.222000, 0.000000), r0.yzwy  
  62: mad r1.xyz, r1.xxxx, v0.xyzx, -r0.yzwy  
  63: mad r0.yzw, v0.wwww, r1.xxyz, r0.yyzw  
  64: add r1.xyz, -r0.yzwy, v1.xyzx  
  65: mad r0.yzw, v1.wwww, r1.xxyz, r0.yyzw  
  66: mul o0.xyz, r0.xxxx, r0.yzwy  
  67: mov o0.w, r0.x  
  68: ret

सामान्य तौर पर, शेडर थोड़ा अधिक जटिल होता है और मेरे लिए यह पता लगाना कठिन था कि इसमें क्या हो रहा है। उदाहरण के लिए, 1.211303, 21.643608 और 24.189651 जैसे सभी मूल्य कहां से आए?

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

अपारदर्शिता फ़ंक्शन के चार खंड / अंतराल हैं जिन्हें चार नियंत्रण बिंदुओं द्वारा परिभाषित किया गया है:

   // current status: no idea how these are generated  
   const float controlPoint0 = 0.052579;  
   const float controlPoint1 = 0.878136;  
   const float controlPoint2 = 0.924339;  
   const float controlPoint3 = 0.965679;

मुझे नहीं पता कि उन्हें कैसे चुना गया / गणना की गई।

जैसा कि हम कोडांतरक कोड से देख सकते हैं, पहली शर्त सिर्फ जाँच कर रही है कि इनपुट मूल्य सीमा में है [controlPoint0 - controlPointVOD]। यदि नहीं, तो अपारदर्शिता सिर्फ 0.0 है।

   // Input for the opacity function
   float y = saturate(Input.Texcoords.y);  // r0.x
     
   // Value of opacity function.  
   // 0 - no change  
   // 1 - full color  
   float opacity = 0.0;  
     
   [branch]   
   if (y >= controlPoint0 && y <= controlPoint3)  
   {  
      ...

नीचे दिए गए कोडांतरक कोड का डिक्रिप्शन आवश्यक है यदि हम यह समझना चाहते हैं कि अपारदर्शिता कार्य कैसे होता है:

   6: add r0.z, r0.x, l(-0.052579)   
   7: mul r1.w, r0.z, l(1.211303)   
   8: mov_sat r0.z, r1.w   
   9: mad r0.w, r0.z, l(-2.000000), l(3.000000)   
  10: mul r0.z, r0.z, r0.z   
  11: mul r0.z, r0.z, r0.w   
  12: mul r2.x, r0.z, l(0.084642)

लाइन 9 में गुणांक '-2.0' और '3.0' है, जो स्मूथस्टेप फ़ंक्शन के उपयोग पर संकेत देता है । हां, यह एक अच्छा अनुमान है।

प्रोटोटाइप के साथ HLSL smoothstep फंक्शन: ret smoothstep (न्यूनतम, अधिकतम, x) हमेशा x को [ min-max ] तक सीमित करता है । देखने का एक कोडांतरक बिंदु से, इस घटाता गया मिनट इनपुट मूल्य (कि लाइन 9 पर r0.z से है,) से है, लेकिन उस कोड में ऐसा कुछ भी नहीं है। के लिए अधिकतम, इस इनपुट मूल्य का एक गुणन का तात्पर्य है, लेकिन कोड में 'mul_sat' जैसी कोई बात नहीं है। इसके बजाय, 'mov_sat' है। यह हमें बताता है कि मिनट और अधिकतम smoothstep के कार्यों 0 कर रहे हैं और 1.

अब हम जानते हैं कि एक्सअंतराल में होना चाहिए [0, 1]। जैसा कि ऊपर कहा गया है, अपारदर्शिता कार्य में तीन खंड हैं। यह स्पष्ट रूप से संकेत देता है कि कोड उस जगह की तलाश कर रहा है जहां हम अंतराल [सेगमेंटस्टार्ट-सेगमेंट] में हैं।

जवाब लिनस्टेप फ़ंक्शन है!

 float linstep(float min, float max, float v)  
 {  
   return ( (v-min) / (max-min) );  
 }

उदाहरण के लिए, चलो पहला खंड लेते हैं: [०.०५२५ 0. ९ - ०.13136१३६]। घटाव लाइन 6 पर है। यदि हम विभाजन को गुणन द्वारा प्रतिस्थापित करते हैं -> 1.0 / (0.878136 - 0.052579) = 1.0 / 0.825557 = ~ 1.211303।

स्मूथस्टेप का परिणाम सीमा [0, 1] में है। लाइन 12 पर गुणा सेगमेंट का वजन है। प्रत्येक खंड का अपना वजन होता है, जिससे आप इस विशेष खंड की अधिकतम अस्पष्टता को नियंत्रित कर सकते हैं।

इसका अर्थ है कि पहले खंड [0.052579 - 0.878136] के लिए, अपारदर्शिता [0 - 0.084642] श्रेणी में है।

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

 float getOpacityFunctionValue(float x, float cpLeft, float cpRight, float weight)  
 {  
   float val = smoothstep( 0, 1, linstep(cpLeft, cpRight, x) );  
   return val * weight;  
 }

तो, पूरे बिंदु बस इसी खंड के लिए इस फ़ंक्शन को कॉल करने के लिए है।

वजन पर एक नज़र डालें:

   const float weight0 = 0.084642;  
   const float weight1 = 0.889658;  
   const float weight2 = 0.974300; // note: weight0+weight1 = weight2

कोडांतरक कोड के अनुसार, अस्पष्टता (x) फ़ंक्शन की गणना निम्नानुसार की जाती है:

   float opacity = 0.0;

   [branch]   
   if (y >= controlPoint0 && y <= controlPoint3)  
   {  
     // Range of v: [0, weight0]  
     float v = getOpacityFunctionValue(y, controlPoint0, controlPoint1, weight0);  
     opacity = v;  
     
     [branch]  
     if ( y >= controlPoint1 )  
     {  
       // Range of v: [0, weight1]  
       float v = getOpacityFunctionValue(y, controlPoint1, controlPoint2, weight1);  
       opacity = weight0 + v;  
   
       [branch]  
       if (y >= controlPoint2)  
       {  
         // Range of v: [0, weight2]  
         float v = getOpacityFunctionValue(y, controlPoint2, controlPoint3, weight2);
         opacity = weight2 - v;          
       }  
     }  
   }

यहाँ अस्पष्टता समारोह का एक ग्राफ है। आप आसानी से अस्पष्टता में तेज वृद्धि देख सकते हैं, जो एक शूटिंग स्टार के शरीर की शुरुआत का संकेत देता है:

ग्राफ अपारदर्शिता कार्य।

लाल चैनल - अपारदर्शिता मान।
हरा चैनल - नियंत्रण बिंदु।
नीला चैनल - वज़न।

अपारदर्शिता की गणना करने के बाद, बाकी सब सिर्फ परिष्करण स्पर्श है। फिर अतिरिक्त गुणन होते हैं: सितारों की अस्पष्टता, शूटिंग स्टार का रंग और कोहरे का प्रभाव। TW3 शेड्स में हमेशा की तरह, आप यहाँ 1.0 से निरर्थक गुणन पा सकते हैं:

   // cb4_v1.x = 1.0  
   float starsOpacity = 1.0 - cb0_v9.w * cb4_v1.x;    
   opacity *= starsOpacity;  

   // Calculate color of a shooting star  
   // cb4_v0.x = 10.0
   // cb2_v2.rgb = (1.0, 1.0, 1.0)
   float3 color = cb2_v2.rgb * cb4_v0.x;
     
   // cb2_v2.w = 1  
   opacity *= cb2_v2.w;
     
   FogResult fr = { Input.FogParams, Input.AerialParams };  
   color = ApplyFog(fr, color);
     
   return float4( color*opacity, opacity);  
 }

4. सारांश

मुख्य कठिनाई अस्पष्टता समारोह के साथ भाग में है। इसे डिकोड करने के बाद, बाकी सब कुछ समझने में काफी सरल है।

मैंने ऊपर कहा है कि पिक्सेल shader थोड़ा अधिक जटिल है। वास्तव में, हम केवल अस्पष्टता (x) फ़ंक्शन के मूल्य के बारे में परवाह करते हैं , जो r2.x (लाइन 49 पर शुरू) में संग्रहीत है। हालांकि, कोडांतरक कोड में अस्पष्टता समारोह तीन अतिरिक्त चर बनाता है: minRange (r2.y), maxRange (r2.z) और मूल्य (r2.w)। वे सभी पैरामीटर हैं जिनका उपयोग अपारदर्शिता की गणना के लिए किया जाता है जब अपारदर्शिता (x) का उपयोग नहीं किया जाता है:

lerp( minRange, maxRange, smoothstep(0, 1, value) );

वास्तव में, अंतिम अपारदर्शिता मान को लाइन 55 पर सशर्त शाखा में प्राप्त किया जाता है - यदि इनपुट मान x हैसीमा में है [controlPoint0 - controlPoint3], इसका मतलब है कि अस्पष्टता फ़ंक्शन का उपयोग किया जाता है, इसलिए r2.x का चयन किया जाता है। अन्यथा, जब x अंतराल के बाहर होता है, तो अपारदर्शिता की गणना r0.x से की जाती है, अर्थात उपरोक्त समीकरण के अनुसार।

मैंने अंतराल के बाहर कुछ पिक्सल को नियंत्रित किया [controlPoint0 - controlPoint3], और अंतिम अस्पष्टता हमेशा शून्य हो गई।

आज के लिए इतना ही। और, हमेशा की तरह, पढ़ने के लिए धन्यवाद।

The Witcher 3 के प्रतिपादन की रिवर्स इंजीनियरिंग: विभिन्न आकाश प्रभाव

भाग 1. सिरस बादल

जियोमेट्रिक और वर्टेक्स शेडर

पिक्सेल shader

Z- दिशा उलटी धूप

क्लाउड टेक्सचर सैंपलिंग

ओवरले मानदंड

चमक (1)

चमक (2)

बादल का रंग

क्षितिज पर सिरस के बादल अधिक दिखाई देते हैं

शोर बनावट नमूना

यह सब एक साथ डालें

संपूर्ण

भाग 2. कोहरा

कोहरा छा गया

परिवेश रोड़ा का विनियमन

यह सब एक साथ डालें

कुछ डिबगिंग स्क्रीनशॉट

संपूर्ण

भाग 3. शूटिंग सितारे

1. सामान्य अवलोकन

2. ज्यामिति

3. पिक्सेल शेडर

4. सारांश

More articles: