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

अनुवाद का पहला भाग यहाँ है । इस भाग में, हम बारिश के दौरान तीखेपन, औसत चमक, चाँद चरणों और वायुमंडलीय घटनाओं के प्रभाव के बारे में बात करेंगे।

भाग 6. तेज करो

इस भाग में, हम द विचर 3 - शार्पन से एक और पोस्ट-प्रोसेसिंग प्रभाव पर करीब से नज़र डालेंगे।

Sharpening आउटपुट इमेज को थोड़ा शार्प बनाता है। यह प्रभाव हमें फ़ोटोशॉप और अन्य ग्राफिक संपादकों से पता चलता है।

द विचर 3 में, शार्पनिंग के दो विकल्प हैं: निम्न और उच्च। मैं उनके बीच के अंतर के बारे में बात करूंगा, लेकिन अभी के लिए, हम स्क्रीनशॉट पर एक नज़र डालते हैं:


विकल्प "कम" - तक


विकल्प "कम" - के बाद


उच्च विकल्प - अप करने के लिए


विकल्प "उच्च" - के बाद

यदि आप अधिक विस्तृत (संवादात्मक) तुलनाओं पर एक नज़र डालना चाहते हैं, तो एनविडिया द विचर 3 डी गाइड में अनुभाग देखें । जैसा कि आप देख सकते हैं, प्रभाव विशेष रूप से घास और पत्ते पर ध्यान देने योग्य है।

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


इनपुट के संदर्भ में, शार्पनिंग के लिए कलर बफर t0 (LDR के बाद टोन करेक्शन और लेंस फ्लेयर्स) और डेप्थ बफर t1 की आवश्यकता होती है ।

चलो पिक्सेल shader के लिए कोडांतरक कोड की जाँच करें:

ps_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb3[3], immediateIndexed
dcl_constantbuffer cb12[23], 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_siv v0.xy, position
dcl_output o0.xyzw
dcl_temps 7
0: ftoi r0.xy, v0.xyxx
1: mov r0.zw, l(0, 0, 0, 0)
2: ld_indexable(texture2d)(float,float,float,float) r0.x, r0.xyzw, t1.xyzw
3: mad r0.x, r0.x, cb12[22].x, cb12[22].y
4: mad r0.y, r0.x, cb12[21].x, cb12[21].y
5: max r0.y, r0.y, l(0.000100)
6: div r0.y, l(1.000000, 1.000000, 1.000000, 1.000000), r0.y
7: mad_sat r0.y, r0.y, cb3[1].z, cb3[1].w
8: add r0.z, -cb3[1].x, cb3[1].y
9: mad r0.y, r0.y, r0.z, cb3[1].x
10: add r0.y, r0.y, l(1.000000)
11: ge r0.x, r0.x, l(1.000000)
12: movc r0.x, r0.x, l(0), l(1.000000)
13: mul r0.z, r0.x, r0.y
14: round_z r1.xy, v0.xyxx
15: add r1.xy, r1.xyxx, l(0.500000, 0.500000, 0.000000, 0.000000)
16: div r1.xy, r1.xyxx, cb3[0].zwzz
17: sample_l(texture2d)(float,float,float,float) r2.xyz, r1.xyxx, t0.xyzw, s0, l(0)
18: lt r0.z, l(0), r0.z
19: if_nz r0.z
20: div r3.xy, l(0.500000, 0.500000, 0.000000, 0.000000), cb3[0].zwzz
21: add r0.zw, r1.xxxy, -r3.xxxy
22: sample_l(texture2d)(float,float,float,float) r4.xyz, r0.zwzz, t0.xyzw, s0, l(0)
23: mov r3.zw, -r3.xxxy
24: add r5.xyzw, r1.xyxy, r3.zyxw
25: sample_l(texture2d)(float,float,float,float) r6.xyz, r5.xyxx, t0.xyzw, s0, l(0)
26: add r4.xyz, r4.xyzx, r6.xyzx
27: sample_l(texture2d)(float,float,float,float) r5.xyz, r5.zwzz, t0.xyzw, s0, l(0)
28: add r4.xyz, r4.xyzx, r5.xyzx
29: add r0.zw, r1.xxxy, r3.xxxy
30: sample_l(texture2d)(float,float,float,float) r1.xyz, r0.zwzz, t0.xyzw, s0, l(0)
31: add r1.xyz, r1.xyzx, r4.xyzx
32: mul r3.xyz, r1.xyzx, l(0.250000, 0.250000, 0.250000, 0.000000)
33: mad r1.xyz, -r1.xyzx, l(0.250000, 0.250000, 0.250000, 0.000000), r2.xyzx
34: max r0.z, abs(r1.z), abs(r1.y)
35: max r0.z, r0.z, abs(r1.x)
36: mad_sat r0.z, r0.z, cb3[2].x, cb3[2].y
37: mad r0.x, r0.y, r0.x, l(-1.000000)
38: mad r0.x, r0.z, r0.x, l(1.000000)
39: dp3 r0.y, l(0.212600, 0.715200, 0.072200, 0.000000), r2.xyzx
40: dp3 r0.z, l(0.212600, 0.715200, 0.072200, 0.000000), r3.xyzx
41: max r0.w, r0.y, l(0.000100)
42: div r1.xyz, r2.xyzx, r0.wwww
43: add r0.y, -r0.z, r0.y
44: mad r0.x, r0.x, r0.y, r0.z
45: max r0.x, r0.x, l(0)
46: mul r2.xyz, r0.xxxx, r1.xyzx
47: endif
48: mov o0.xyz, r2.xyzx
49: mov o0.w, l(1.000000)
50: ret

कोडांतरक कोड की 50 लाइनें एक व्यवहार्य कार्य की तरह दिखती हैं। इसे हल करने के लिए नीचे उतरें।

शार्प वैल्यू जनरेशन

पहला कदम गहराई बफर (पंक्ति 1) को लोड करना है। यह ध्यान देने योग्य है कि "द विचर 3" एक औंधा गहराई (1.0 - करीब, 0.0 - दूर) का उपयोग करता है। जैसा कि आप जानते हैं, हार्डवेयर की गहराई को बिना रेखा के साथ बांधा जाता है ( विवरण के लिए यह लेख देखें )।

लाइनें 3-6 इस हार्डवेयर गहराई को जोड़ने का एक बहुत ही दिलचस्प तरीका प्रदान करती हैं [1.0 - 0.0] [निकट-दूर] मूल्यों के साथ (हमने उन्हें मैट्रिक्सपर्सिवेफिएव स्टेज पर सेट किया है)। स्थिर बफर से मानों पर विचार करें:


मान ०.२ के "पास" और "सुदूर" ५००० के मान के बाद, हम cb12_v21.xy के मूल्यों की गणना कर सकते हैं:

cb12_v21.y = 1.0 / near
cb12_v21.x = - (1.0 / near) + (1.0 / near) * (near / far)

TW3 कोड में कोड का यह टुकड़ा काफी सामान्य है, इसलिए मुझे लगता है कि यह सिर्फ एक फ़ंक्शन है।

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


cb3_v1.xy और cb3_v2.xy - यह छोटी और लंबी दूरी पर तीक्ष्ण प्रभाव की चमक है। चलो उन्हें तीक्ष्णता से बुलाएं और तेज करें। और यह "कम" और "उच्च" के बीच का एकमात्र अंतर है, जो कि द विचर 3 में इस आशय का है।

अब परिणामी अनुपात का उपयोग करने का समय है। लाइन्स 8-9 बस lerp(sharpenNear, sharpenFar, interpolationCoeff) । यह किस लिए है? इसके लिए धन्यवाद, हमें गेराल्ट के पास और उससे दूर अलग-अलग चमक मिलती है। एक बार देख लो:


शायद यह मुश्किल से ध्यान देने योग्य है, लेकिन यहां हमने खिलाड़ी (2.177151) के बगल में तेज चमक की दूरी के आधार पर प्रक्षेप किया और प्रभाव चमक बहुत दूर (1.91303) है। इस गणना के बाद, हम 1.0 को चमक (पंक्ति 10) में जोड़ते हैं। इसकी आवश्यकता क्यों है? मान लीजिए ऊपर दिखाए गए ऑपरेशन lerp ने हमें 0.0 दिया। 1.0 जोड़ने के बाद, हम स्वाभाविक रूप से 1.0 प्राप्त करते हैं, और यह एक ऐसा मूल्य है जो पैनापन करते समय पिक्सेल को प्रभावित नहीं करेगा। इसके बारे में नीचे पढ़ें।

तेज करते हुए, हम आकाश को प्रभावित नहीं करना चाहते हैं। यह एक साधारण सशर्त जांच जोड़कर प्राप्त किया जा सकता है:

// sharpen
float fSkyboxTest = (fDepth >= 1.0) ? 0 : 1;

द विचर 3 में, आकाश की पिक्सेल गहराई का मान 1.0 है, इसलिए हम इसका उपयोग एक प्रकार का "बाइनरी फ़िल्टर" प्राप्त करने के लिए करते हैं (एक दिलचस्प तथ्य: इस मामले में, चरण सही ढंग से काम नहीं करेगा)।

अब हम "स्काई फिल्टर" द्वारा प्रक्षेपित चमक को गुणा कर सकते हैं:


यह गुणन पंक्ति 13 पर किया जाता है।

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

// sharpen
float fSharpenAmount = fSharpenIntensity * fSkyboxTest;

पिक्सेल नमूना केंद्र

SV_Position का एक पहलू है जो यहां महत्वपूर्ण होगा: एक आधा पिक्सेल ऑफसेट । यह पता चला है कि ऊपरी बाएँ कोने (0, 0) के पिक्सेल में SV_Position.xy के संदर्भ में निर्देशांक (0, 0) नहीं है, लेकिन (0.5, 0.5) है। वाह!

यहां हम पिक्सेल के केंद्र में एक नमूना लेना चाहते हैं, तो आइए 14-16 लाइनों को देखें। आप उन्हें एचएलएसएल में लिख सकते हैं:

// .
// "" SV_Position.xy.
float2 uvCenter = trunc( Input.Position.xy );

// ,
uvCenter += float2(0.5, 0.5);
uvCenter /= g_Viewport.xy

और बाद में, हम टेक्सकोर्ड्स "यूवीकेंटर" से इनपुट रंग की बनावट का नमूना लेते हैं। चिंता न करें, नमूने का परिणाम "सामान्य" विधि (SV_Position.xy / ViewportSize.xy) के समान होगा।

तेज करना या न करना

पैनापन का उपयोग करने पर निर्णय fSharpenAmount पर निर्भर करता है।

//
float3 colorCenter = TexColorBuffer.SampleLevel( samplerLinearClamp, uvCenter, 0 ).rgb;

//
float3 finalColor = colorCenter;

if ( fSharpenAmount > 0 )
{
// sharpening...
}

return float4( finalColor, 1 );

पैना

यह एल्गोरिथम के इनसाइड पर एक नज़र डालने का समय है।

अनिवार्य रूप से, यह निम्नलिखित क्रियाएं करता है:

- पिक्सेल के कोनों पर चार बार इनपुट रंग की बनावट के नमूने,

- नमूने जोड़ता है और औसत मूल्य की गणना करता है,

- "केंद्र" और "कोने एवरेज" के बीच अंतर की गणना करता है:

- अंतर का अधिकतम निरपेक्ष घटक पाता है,

- अधिकतम को सही करता है। पेट। पैमाने + पूर्वाग्रह मूल्यों का उपयोग कर घटक,

- अधिकतम का उपयोग करके प्रभाव की मात्रा निर्धारित करता है। पेट। अंग

- "CenterColor" और "averageColor" के लिए चमक मूल्य (लूमा) की गणना करता है,

- रंगकर्मी को उसके लूमा में विभाजित करता है,

- प्रभाव की भयावहता के आधार पर एक नए, प्रक्षेपित लूमा मान की गणना करता है,

- नए लूमा मूल्य द्वारा कलरकेंटर को गुणा करें।

बहुत सारे काम, और मेरे लिए यह पता लगाना मुश्किल था, क्योंकि मैंने कभी तेज पैनापन के साथ प्रयोग नहीं किया था।

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

यह एक पिक्सेल छवि के उदाहरण का उपयोग करके दिखाया जाएगा (कलाकार का कौशल स्तर एक विशेषज्ञ है ):


Shader में सभी पढ़ते हैं बिलिनियर सैंपलिंग (D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT)।

प्रत्येक कोण पर केंद्र से ऑफसेट (0.5,, 0.5) है, जो कोण पर निर्भर करता है।

देखें कि इसे एचएलएसएल पर कैसे लागू किया जा सकता है? आइए देखें:

float2 uvCorner;
float2 uvOffset = float2( 0.5, 0.5 ) / g_Viewport.xy; // remember about division!

float3 colorCorners = 0;

//
// -0,5, -0.5
uvCorner = uvCenter - uvOffset;
colorCorners += TexColorBuffer.SampleLevel( samplerLinearClamp, uvCorner, 0 ).rgb;

//
// +0.5, -0.5
uvCorner = uvCenter + float2(uvOffset.x, -uvOffset.y);
colorCorners += TexColorBuffer.SampleLevel( samplerLinearClamp, uvCorner, 0 ).rgb;

//
// -0.5, +0.5
uvCorner = uvCenter + float2(-uvOffset.x, uvOffset.y);
colorCorners += TexColorBuffer.SampleLevel( samplerLinearClamp, uvCorner, 0 ).rgb;

//
// +0.5, +0.5
uvCorner = uvCenter + uvOffset;
colorCorners += TexColorBuffer.SampleLevel( samplerLinearClamp, uvCorner, 0 ).rgb;

तो, अब सभी चार नमूनों को "colorCorners" चर में संक्षेपित किया गया है। आइए इन चरणों का पालन करें:

//
float3 averageColorCorners = colorCorners / 4.0;

//
float3 diffColor = colorCenter - averageColorCorners;

// . . RGB-
float fDiffColorMaxComponent = max( abs(diffColor.x), max( abs(diffColor.y), abs(diffColor.z) ) );

//
float fDiffColorMaxComponentScaled = saturate( fDiffColorMaxComponent * sharpenLumScale + sharpenLumBias );

// .
// "1.0" - fSharpenIntensity 1.0.
float fPixelSharpenAmount = lerp(1.0, fSharpenAmount, fDiffColorMaxComponentScaled);

// "" .
float lumaCenter = dot( LUMINANCE_RGB, finalColor );
float lumaCornersAverage = dot( LUMINANCE_RGB, averageColorCorners );

// "centerColor"
float3 fColorBalanced = colorCenter / max( lumaCenter, 1e-4 );

//
float fPixelLuminance = lerp(lumaCornersAverage, lumaCenter, fPixelSharpenAmount);

//
finalColor = fColorBalanced * max(fPixelLuminance, 0.0);
}

return float4(finalColor, 1.0);

अधिकतम की गणना करके एज की पहचान की जाती है। पेट। अंतर घटक। स्मार्ट चाल! इसका दृश्य देखें:


अंतर के अधिकतम निरपेक्ष घटक का दृश्य।

बहुत बढ़िया। तैयार एचएलएसएल शेडर यहां उपलब्ध है । बहुत गरीब स्वरूपण के लिए क्षमा करें। आप मेरे HLSLexplorer प्रोग्राम का उपयोग कर सकते हैं और कोड के साथ प्रयोग कर सकते हैं।

मैं खुशी से कह सकता हूं कि ऊपर दिए गए कोड गेम में समान कोडांतरक कोड बनाता है!

संक्षेप में: The Witcher 3 sharpness shader बहुत अच्छी तरह से लिखा गया है (ध्यान दें कि fPixelSharpenAmount 1.0 से अधिक है! यह दिलचस्प है ...)। इसके अलावा, प्रभाव की चमक को बदलने का मुख्य तरीका निकट / दूर की वस्तुओं की चमक है। इस खेल में, वे निरंतर नहीं हैं; मैंने मूल्यों के कई उदाहरण संकलित किए हैं:

स्केलिग:

	sharpenNear	sharpenFar	sharpenDistanceScale	sharpenDistanceBias	sharpenLumScale	sharpenLumBias
कम
उच्च	2.0	1.8	0.025	-0.25	-१३.३३,३३३	1.33333

कायर मोरेन:

	sharpenNear	sharpenFar	sharpenDistanceScale	sharpenDistanceBias	sharpenLumScale	sharpenLumBias
कम	.५७,७५१	.३१,३०३	.०६,६६५	-.३३,२५६	-1.0	2.0
उच्च	२.१७,७५१	१.९१,३०३	.०६,६६५	-.३३,२५६	-1.0	2.0

भाग 7. औसत चमक

वर्तमान फ्रेम की औसत चमक की गणना का संचालन लगभग किसी भी आधुनिक वीडियो गेम में पाया जा सकता है। यह मान अक्सर बाद में आंख अनुकूलन और तानवाला सुधार के प्रभाव के लिए उपयोग किया जाता है (पोस्ट के पिछले भाग में देखें)। सरल समाधानों में, चमक की गणना का उपयोग, बनावट, 512 ^{2 के} लिए किया जाता है, फिर इसके एमआइपी स्तर की गणना और बाद के आवेदन। यह आमतौर पर काम करता है, लेकिन संभावनाओं को बहुत सीमित करता है। अधिक जटिल समाधान कम्प्यूटेशनल शेड का उपयोग करते हैं जो उदाहरण के लिए, समानांतर कमी करते हैं ।

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

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

चमक वितरण

ये दोनों पास किसी भी फ्रेम विश्लेषक में खोजने के लिए काफी आसान हैं। आंखों का अनुकूलन करने से ठीक पहले ये डिस्पैच कॉल हैं:


आइए इस पास के लिए इनपुट देखें। उसे दो बनावट चाहिए:

1) एचडीआर कलर बफर, जिसका स्केल 1/4 x 1/4 तक कम हो जाता है (उदाहरण के लिए, 1920x1080 से 480x27070),

2) फुलस्क्रीन डेप्थ बफर


1/4 x 1/4 HDR रंग बफर। ट्रिकी ट्रिक पर ध्यान दें - यह बफर एक बड़े बफर का हिस्सा है। बफर्स ​​का पुन: उपयोग करना अच्छा अभ्यास है।


फुलस्क्रीन डेप्थ बफर

कलर बफर को ज़ूम आउट क्यों करें? मुझे लगता है कि यह प्रदर्शन के बारे में है।

इस पास के आउटपुट के लिए, यह एक संरचित बफर है। 4 बाइट्स के 256 तत्व प्रत्येक।

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

महत्वपूर्ण: औसत चमक की गणना करने में पहला कदम संरचित बफर के सभी तत्वों को शून्य पर रीसेट करने के लिए ClearUnorderedAccessViewUint को कॉल करता है।

आइए कम्प्यूटेशनल shader के कोडांतरक कोड का अध्ययन करें (यह हमारे संपूर्ण विश्लेषण में पहला कम्प्यूटेशनल shader है!)

cs_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb0[3], immediateIndexed
dcl_resource_texture2d (float,float,float,float) t0
dcl_resource_texture2d (float,float,float,float) t1
dcl_uav_structured u0, 4
dcl_input vThreadGroupID.x
dcl_input vThreadIDInGroup.x
dcl_temps 6
dcl_tgsm_structured g0, 4, 256
dcl_thread_group 64, 1, 1
0: store_structured g0.x, vThreadIDInGroup.x, l(0), l(0)
1: iadd r0.xyz, vThreadIDInGroup.xxxx, l(64, 128, 192, 0)
2: store_structured g0.x, r0.x, l(0), l(0)
3: store_structured g0.x, r0.y, l(0), l(0)
4: store_structured g0.x, r0.z, l(0), l(0)
5: sync_g_t
6: ftoi r1.x, cb0[2].z
7: mov r2.y, vThreadGroupID.x
8: mov r2.zw, l(0, 0, 0, 0)
9: mov r3.zw, l(0, 0, 0, 0)
10: mov r4.yw, l(0, 0, 0, 0)
11: mov r1.y, l(0)
12: loop
13: utof r1.z, r1.y
14: ge r1.z, r1.z, cb0[0].x
15: breakc_nz r1.z
16: iadd r2.x, r1.y, vThreadIDInGroup.x
17: utof r1.z, r2.x
18: lt r1.z, r1.z, cb0[0].x
19: if_nz r1.z
20: ld_indexable(texture2d)(float,float,float,float) r5.xyz, r2.xyzw, t0.xyzw
21: dp3 r1.z, r5.xyzx, l(0.212600, 0.715200, 0.072200, 0.000000)
22: imul null, r3.xy, r1.xxxx, r2.xyxx
23: ld_indexable(texture2d)(float,float,float,float) r1.w, r3.xyzw, t1.yzwx
24: eq r1.w, r1.w, cb0[2].w
25: and r1.w, r1.w, cb0[2].y
26: add r2.x, -r1.z, cb0[2].x
27: mad r1.z, r1.w, r2.x, r1.z
28: add r1.z, r1.z, l(1.000000)
29: log r1.z, r1.z
30: mul r1.z, r1.z, l(88.722839)
31: ftou r1.z, r1.z
32: umin r4.x, r1.z, l(255)
33: atomic_iadd g0, r4.xyxx, l(1)
34: endif
35: iadd r1.y, r1.y, l(64)
36: endloop
37: sync_g_t
38: ld_structured r1.x, vThreadIDInGroup.x, l(0), g0.xxxx
39: mov r4.z, vThreadIDInGroup.x
40: atomic_iadd u0, r4.zwzz, r1.x
41: ld_structured r1.x, r0.x, l(0), g0.xxxx
42: mov r0.w, l(0)
43: atomic_iadd u0, r0.xwxx, r1.x
44: ld_structured r0.x, r0.y, l(0), g0.xxxx
45: atomic_iadd u0, r0.ywyy, r0.x
46: ld_structured r0.x, r0.z, l(0), g0.xxxx
47: atomic_iadd u0, r0.zwzz, r0.x
48: ret

और एक निरंतर बफर:


हम पहले से ही जानते हैं कि पहला इनपुट एचडीआर कलर बफर है। फुलएचडी के साथ, इसका रिज़ॉल्यूशन 480x270 है। आइए डिस्पैच कॉल को देखें।

डिस्पैच (270, 1, 1) - इसका मतलब है कि हम 270 थ्रेड समूह चलाते हैं। सीधे शब्दों में कहें, हम रंग बफर के प्रत्येक पंक्ति के धागे का एक समूह चलाते हैं।


प्रत्येक थ्रेड समूह HDR रंग बफ़र की एक पंक्ति निष्पादित करता है

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

प्रत्येक थ्रेड समूह में X दिशा में 64 थ्रेड्स होते हैं (dcl_thread_group 64, 1, 1), साथ ही साथ साझा की गई मेमोरी, 4 बाइट्स के साथ 256 तत्व (dcl_tgsm_structured g0, 4, 256)।

ध्यान दें कि shader में हम SV_GroupThreadID (vThreadIDInGroup.x) [0-63] और SV_GroupID (vThreadGroupID.x) [0-269] का उपयोग करते हैं।

1) हम साझा स्मृति शून्य मान के सभी तत्वों को निर्दिष्ट करके शुरू करते हैं। चूंकि कुल मेमोरी में प्रति तत्व 256 तत्व और 64 थ्रेड्स होते हैं, इसलिए यह आसानी से एक साधारण लूप के साथ किया जा सकता है:

// - .
// 64 , 4 .
[unroll] for (uint idx=0; idx < 4; idx++)
{
const uint offset = threadID + idx*64;
shared_data[ offset ] = 0;
}

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

3) अब हम एक लूप निष्पादित कर रहे हैं, जो मोटे तौर पर इस तरह लिखा जा सकता है:

// cb0_v0.x - . 1920x1080 1920/4 = 480;
float ViewportSizeX = cb0_v0.x;
[loop] for ( uint PositionX = 0; PositionX < ViewportSizeX; PositionX += 64 )
{
...

यह 64 के वेतन वृद्धि के साथ लूप के लिए एक सरल है (क्या आप पहले से ही समझते हैं कि क्यों?)।

अगला कदम लोड पिक्सेल की स्थिति की गणना करना है।

चलिए इसके बारे में सोचते हैं।

Y समन्वय के लिए, हम SV_GroupID.x का उपयोग कर सकते हैं क्योंकि हमने 270 थ्रेड समूह लॉन्च किए हैं।

एक्स के समन्वय के लिए, हम ... वर्तमान समूह प्रवाह का लाभ उठा सकते हैं! चलो इसे करने की कोशिश करते हैं।

चूंकि प्रत्येक समूह में 64 धागे हैं, ऐसे समाधान सभी पिक्सेल को बायपास करेंगे।

धागा समूह (0, 0, 0) पर विचार करें।

- धारा (0, 0, 0) पिक्सल (0, 0), (64, 0), (128, 0), (192, 0), (256, 0), (320, 0), (384) को प्रोसेस करेगी। 0), (448,0)।

- थ्रेड (1, 0, 0) पिक्सल (1, 0), (65, 0), (129, 0), (193, 0), (257, 0), (321, 0), (385,) को प्रोसेस करेगा। 0), (449, 0) ...

- धारा (63, 0, 0) पिक्सल (63, 0), (127, 0), (191, 0), (255, 0), (319, 0), (383, 0), (447) को संसाधित करेगी। 0)

इस प्रकार, सभी पिक्सेल संसाधित किए जाएंगे।

हमें यह भी सुनिश्चित करने की आवश्यकता है कि हम रंग बफर के बाहर से पिक्सेल लोड न करें:

// X. Y GroupID.
uint CurrentPixelPositionX = PositionX + threadID;
uint CurrentPixelPositionY = groupID;
if ( CurrentPixelPositionX < ViewportSizeX )
{
// HDR- .
// HDR- , .
uint2 colorPos = uint2(CurrentPixelPositionX, CurrentPixelPositionY);
float3 color = texture0.Load( int3(colorPos, 0) ).rgb;
float luma = dot(color, LUMA_RGB);

आप देखते हैं? यह बहुत आसान है!

मैंने चमक (असेंबलर कोड की लाइन 21) की भी गणना की।

महान, हमने पहले से ही एक रंग पिक्सेल से चमक की गणना की है। अगला कदम लोड करना है (नमूना नहीं!) संबंधित गहराई मूल्य।

लेकिन यहां हमें एक समस्या है, क्योंकि हमने पूर्ण संकल्प की गहराई के बफर को जोड़ा। इसके बारे में क्या करना है?

यह आश्चर्यजनक रूप से सरल है - बस कुछ स्थिर (cb0_v2.z) द्वारा रंग जमा करें। हमने चार बार एचडीआर कलर बफर डाउन किया। इसलिए मूल्य 4 है!

const int iDepthTextureScale = (int) cb0_v2.z;
uint2 depthPos = iDepthTextureScale * colorPos;
float depth = texture1.Load( int3(depthPos, 0) ).x;

अब तक तो अच्छा है! लेकिन ... हम 24-25 लाइनों के लिए मिला ...

24: eq r2.x, r2.x, cb0[2].w
25: and r2.x, r2.x, cb0[2].y

So. पहले हमारे पास फ्लोटिंग पॉइंट समानता की तुलना है , इसका परिणाम r2.x में लिखा गया है, और इसके ठीक बाद जाता है ... क्या? बिटवाइज़ एंड ?? गंभीरता से? एक अस्थायी बिंदु मान के लिए? ये क्या ???

'Eq + और' समस्या

मुझे सिर्फ इतना कहना है कि मेरे लिए यह सबसे कठिन हिस्सा था। मैं भी अजीब asint / asfloat संयोजन की कोशिश की ...

और अगर आप थोड़ा अलग दृष्टिकोण का उपयोग करते हैं? एचएलएसएल में सामान्य फ्लोट-फ्लोट की तुलना करते हैं।

float DummyPS() : SV_Target0
{
float test = (cb0_v0.x == cb0_v0.y);
return test;
}

और यहाँ कोडांतरक कोड में आउटपुट है:

0: eq r0.x, cb0[0].y, cb0[0].x
1: and o0.x, r0.x, l(0x3f800000)
2: ret

दिलचस्प है, है ना? मुझे यहां "और" देखने की उम्मीद नहीं थी।

0x3f800000 सिर्फ 1.0f है ... यह तार्किक है क्योंकि हम 1.0 और 0.0 प्राप्त करते हैं अन्यथा यदि तुलना सफल होती है।

लेकिन क्या होगा अगर हम 1.0 को कुछ अन्य मूल्य के साथ "प्रतिस्थापित" करें? उदाहरण के लिए, इस तरह:

float DummyPS() : SV_Target0
{
float test = (cb0_v0.x == cb0_v0.y) ? cb0_v0.z : 0.0;
return test;
}

हमें निम्न परिणाम मिलते हैं:

0: eq r0.x, cb0[0].y, cb0[0].x
1: and o0.x, r0.x, cb0[0].z
2: ret

हा! इसने काम किया। यह एचएलएसएल कंपाइलर का जादू मात्र है। नोट: यदि आप 0.0 को किसी और चीज़ से बदलते हैं, तो आपको बस movc मिल जाएगा।

आइए कम्प्यूटेशनल शेडर पर वापस जाएं। अगला कदम यह सत्यापित करना है कि गहराई cb0_v2.w के बराबर है। यह हमेशा 0.0 के बराबर होता है - दूसरे शब्दों में, हम जांचते हैं कि क्या एक पिक्सेल एक दूर के विमान (आकाश में) पर है। यदि ऐसा है, तो हम इस गुणांक को कुछ मान देते हैं, लगभग 0.5 (मैंने कई फ़्रेमों पर जांच की)।

इस गणना गुणांक का उपयोग रंग की चमक और "आकाश" की चमक (cb0_v2.x मान, जो प्रायः 0.0 के बराबर होता है) के बीच अंतर करने के लिए किया जाता है। मैं मानता हूं कि औसत चमक की गणना में आकाश के महत्व को नियंत्रित करना आवश्यक है। आमतौर पर महत्व कम हो जाता है। बहुत चतुर विचार।

// , ( ). , ,
// .
float value = (depth == cb0_v2.w) ? cb0_v2.y : 0.0;

// 'value' 0.0, lerp 'luma'. 'value'
// ( 0.50), luma . (cb0_v2.x 0.0).
float lumaOk = lerp( luma, cb0_v2.x, value );

चूंकि हमारे पास lumaOk है, इसलिए अगला कदम एक अच्छा वितरण बनाने के लिए इसके प्राकृतिक लघुगणक की गणना करना है। लेकिन रुकिए, हम बताते हैं कि lumaOk 0.0 है। हम जानते हैं कि लॉग (0) का मान अपरिभाषित है, इसलिए हम 1.0 जोड़ते हैं क्योंकि लॉग (1) = 0.0 है।

उसके बाद, हम 256 कोशिकाओं में इसे वितरित करने के लिए गणना किए गए लघुगणक को 128 तक मापते हैं। बहुत होशियार!

और यह यहाँ से है कि यह मान 88.722839 लिया जाता है। यह एक 128 * (2) ।

यह उसी तरह है जैसे एचएलएसएल लॉगरिथम की गणना करता है।

HLSL कोडांतरक कोड में केवल एक ही कार्य है जो लघुगणक की गणना करता है: लॉग , और इसका आधार 2 है।

// , lumaOk 0.0.
// log(0) undefined
// log(1) = 0.
//
lumaOk = log(lumaOk + 1.0);

// 128
lumaOk *= 128;

अंत में, हम लघुगणकीय रूप से वितरित चमक से सेल के सूचकांक की गणना करते हैं और साझा मेमोरी में संबंधित सेल में 1 जोड़ते हैं।

// . Uint, 256 ,
// , .
uint uLuma = (uint) lumaOk;
uLuma = min(uLuma, 255);

// 1 .
InterlockedAdd( shared_data[uLuma], 1 );

अगला चरण फिर से यह सुनिश्चित करने के लिए एक अवरोध स्थापित करेगा कि पंक्ति में सभी पिक्सेल संसाधित किए गए हैं।

और अंतिम चरण साझा मेमोरी से संरचित बफर में मूल्यों को जोड़ना है। यह एक साधारण लूप के माध्यम से उसी तरह किया जाता है:

// ,
GroupMemoryBarrierWithGroupSync();

// .
[unroll] for (uint idx = 0; idx < 4; idx++)
{
const uint offset = threadID + idx*64;

uint data = shared_data[offset];
InterlockedAdd( g_buffer[offset], data );
}

सामान्य डेटा में थ्रेड समूह में सभी 64 थ्रेड्स भरने के बाद, प्रत्येक थ्रेड आउटपुट मान में 4 मान जोड़ता है।

आउटपुट बफर पर विचार करें। चलिए इसके बारे में सोचते हैं। बफ़र में सभी मानों का योग पिक्सेल की कुल संख्या के बराबर है! (480x270 = 129,600 पर)। यही है, हम जानते हैं कि कितने पिक्सेल में एक विशिष्ट चमक मूल्य है।

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

वह सब है! यह है कि कैसे इस Witcher 3 चमक के एक हिस्टोग्राम की गणना करता है। व्यक्तिगत रूप से, मैंने इस भाग को लिखते समय बहुत कुछ सीखा। सीडी प्रजेकट रेड के लोगों को उनके उत्कृष्ट कार्य के लिए बधाई!

यदि आप एक पूर्ण एचएलएसएल शेडर में रुचि रखते हैं, तो यह यहां उपलब्ध है । मैं हमेशा खेल के करीब के रूप में विधानसभा कोड प्राप्त करने का प्रयास करता हूं और पूरी तरह से खुश हूं कि मैं फिर से सफल हुआ!

औसत चमक गणना

यह "द विचर 3: वाइल्ड हंट" में मध्यम चमक गणना के विश्लेषण का दूसरा भाग है।

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


पहले पास के आउटपुट का एक उदाहरण। 256 तत्व हैं।

उदाहरण के लिए, हमारे फुल-स्क्रीन बफर का आकार 1920x1080 है। ज़ूम आउट करने के बाद, पहले पास में 480x270 बफर का उपयोग किया गया था। बफर में सभी 256 मानों का योग 480 * 270 = 129 600 के बराबर होगा।

इस संक्षिप्त परिचय के बाद, हम अगले चरण पर जाने के लिए तैयार हैं: कंप्यूटिंग के लिए।

इस समय केवल एक थ्रेड समूह का उपयोग किया जाता है (डिस्पैच (1, 1, 1))।

आइए कम्प्यूटेशनल shader के कोडांतरक कोड को देखें:

cs_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb0[1], immediateIndexed
dcl_uav_structured u0, 4
dcl_uav_typed_texture2d (float,float,float,float) u1
dcl_input vThreadIDInGroup.x
dcl_temps 4
dcl_tgsm_structured g0, 4, 256
dcl_thread_group 64, 1, 1
0: ld_structured_indexable(structured_buffer, stride=4)(mixed,mixed,mixed,mixed) r0.x, vThreadIDInGroup.x, l(0), u0.xxxx
1: store_structured g0.x, vThreadIDInGroup.x, l(0), r0.x
2: iadd r0.xyz, vThreadIDInGroup.xxxx, l(64, 128, 192, 0)
3: ld_structured_indexable(structured_buffer, stride=4)(mixed,mixed,mixed,mixed) r0.w, r0.x, l(0), u0.xxxx
4: store_structured g0.x, r0.x, l(0), r0.w
5: ld_structured_indexable(structured_buffer, stride=4)(mixed,mixed,mixed,mixed) r0.x, r0.y, l(0), u0.xxxx
6: store_structured g0.x, r0.y, l(0), r0.x
7: ld_structured_indexable(structured_buffer, stride=4)(mixed,mixed,mixed,mixed) r0.x, r0.z, l(0), u0.xxxx
8: store_structured g0.x, r0.z, l(0), r0.x
9: sync_g_t
10: if_z vThreadIDInGroup.x
11: mul r0.x, cb0[0].y, cb0[0].x
12: ftou r0.x, r0.x
13: utof r0.y, r0.x
14: mul r0.yz, r0.yyyy, cb0[0].zzwz
15: ftoi r0.yz, r0.yyzy
16: iadd r0.x, r0.x, l(-1)
17: imax r0.y, r0.y, l(0)
18: imin r0.y, r0.x, r0.y
19: imax r0.z, r0.y, r0.z
20: imin r0.x, r0.x, r0.z
21: mov r1.z, l(-1)
22: mov r2.xyz, l(0, 0, 0, 0)
23: loop
24: breakc_nz r2.x
25: ld_structured r0.z, r2.z, l(0), g0.xxxx
26: iadd r3.x, r0.z, r2.y
27: ilt r0.z, r0.y, r3.x
28: iadd r3.y, r2.z, l(1)
29: mov r1.xy, r2.yzyy
30: mov r3.z, r2.x
31: movc r2.xyz, r0.zzzz, r1.zxyz, r3.zxyz
32: endloop
33: mov r0.w, l(-1)
34: mov r1.yz, r2.yyzy
35: mov r1.xw, l(0, 0, 0, 0)
36: loop
37: breakc_nz r1.x
38: ld_structured r2.x, r1.z, l(0), g0.xxxx
39: iadd r1.y, r1.y, r2.x
40: utof r2.x, r2.x
41: utof r2.w, r1.z
42: add r2.w, r2.w, l(0.500000)
43: mul r2.w, r2.w, l(0.011271)
44: exp r2.w, r2.w
45: add r2.w, r2.w, l(-1.000000)
46: mad r3.z, r2.x, r2.w, r1.w
47: ilt r2.x, r0.x, r1.y
48: iadd r2.w, -r2.y, r1.y
49: itof r2.w, r2.w
50: div r0.z, r3.z, r2.w
51: iadd r3.y, r1.z, l(1)
52: mov r0.y, r1.z
53: mov r3.w, r1.x
54: movc r1.xzw, r2.xxxx, r0.wwyz, r3.wwyz
55: endloop
56: store_uav_typed u1.xyzw, l(0, 0, 0, 0), r1.wwww
57: endif
58: ret

एक निरंतर बफर है:


आइए कोडांतरक कोड पर एक त्वरित नज़र डालें: दो यूएवी संलग्न हैं (u0: पहले भाग से इनपुट बफर और u1: 1x1 R32_FLOAT प्रारूप की आउटपुट बनावट)। हम यह भी देखते हैं कि प्रति समूह 64 धागे और 4-बाइट साझा समूह मेमोरी के 256 तत्व हैं।

हम इनपुट बफर से डेटा के साथ साझा मेमोरी को भरने से शुरू करते हैं। हमारे पास 64 धागे हैं, इसलिए आपको लगभग पहले जैसा ही करना होगा।

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

// - .
// 64 , 4
// .
[unroll] for (uint idx=0; idx < 4; idx++)
{
const uint offset = threadID + idx*64;
shared_data[ offset ] = g_buffer[offset];
}
// , ,
// .
GroupMemoryBarrierWithGroupSync();

सभी गणना केवल एक धागे में की जाती है, अन्य सभी का उपयोग बफर से मूल्यों को साझा मेमोरी में लोड करने के लिए किया जाता है।

"कंप्यूटिंग" स्ट्रीम में 0. का सूचकांक क्यों है? सैद्धांतिक रूप से, हम अंतराल [0-63] से किसी भी धारा का उपयोग कर सकते हैं, लेकिन 0 के साथ तुलना करने के लिए धन्यवाद, हम अतिरिक्त पूर्णांक-पूर्णांक तुलना ( यानी निर्देश) से बच सकते हैं।

एल्गोरिथ्म पिक्सल के अंतराल के संकेत पर आधारित है जिसे ऑपरेशन में ध्यान में रखा जाएगा।

पंक्ति 11 में, हम पिक्सेल की कुल संख्या प्राप्त करने के लिए चौड़ाई * की ऊँचाई को बढ़ाते हैं और उन्हें अंतराल से दो संख्याओं से गुणा करते हैं [0.0f-1.0f], जो अंतराल की शुरुआत और अंत को दर्शाता है। आगे प्रतिबंधों का उपयोग यह सुनिश्चित करने के लिए किया जाता है कि 0 <= Start <= End <= totalPixels - 1 :

// 0.
[branch] if (threadID == 0)
{
//
uint totalPixels = cb0_v0.x * cb0_v0.y;

// (, , ),
// .
int pixelsToConsiderStart = totalPixels * cb0_v0.z;
int pixelsToConsiderEnd = totalPixels * cb0_v0.w;

int pixelsMinusOne = totalPixels - 1;

pixelsToConsiderStart = clamp( pixelsToConsiderStart, 0, pixelsMinusOne );
pixelsToConsiderEnd = clamp( pixelsToConsiderEnd, pixelsToConsiderStart, pixelsMinusOne );

जैसा कि आप देख सकते हैं, नीचे दो चक्र हैं। उनके साथ समस्या (या उनके कोडांतरक कोड के साथ) यह है कि छोरों के छोर पर अजीब सशर्त संक्रमण हैं। मेरे लिए उन्हें फिर से बनाना बहुत मुश्किल था। पंक्ति 21 पर एक नज़र डालें। "-1" क्यों है? मैं इसे थोड़ा नीचे समझाऊंगा।

पहले चक्र का कार्य PixToConsiderStart को त्यागना और हमें बफर सेल का सूचकांक देना है जिसमें PixToConsiderStart +1 मौजूद है (साथ ही पिछले कक्षों में सभी पिक्सेल की संख्या)।

मान लीजिए कि PixToConsiderStart लगभग 30,000 के बराबर है, और बफर में सेल में "शून्य" में 37,000 पिक्सेल हैं (यह रात में गेम में होता है)। इसलिए, हम लगभग 30001 पिक्सेल के साथ चमक का विश्लेषण शुरू करना चाहते हैं, जो सेल "शून्य" में मौजूद है। इस मामले में, हम तुरंत लूप से बाहर निकलते हैं, जिससे शुरुआती इंडेक्स '0' और जीरो डिस्क्लोज्ड पिक्सल मिलता है।

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

//
int numProcessedPixels = 0;

// [0-255]
int lumaValue = 0;

//
bool bExitLoop = false;

// - "pixelsToConsiderStart" .
// lumaValue, .
[loop]
while (!bExitLoop)
{
// .
uint numPixels = shared_data[lumaValue];

// , lumaValue
int tempSum = numProcessedPixels + numPixels;

// , pixelsToConsiderStart, .
// , lumaValue.
// , pixelsToConsiderStart - "" , , .
[flatten]
if (tempSum > pixelsToConsiderStart)
{
bExitLoop = true;
}
else
{
numProcessedPixels = tempSum;
lumaValue++;
}
}

कोडांतरक कोड की पंक्ति 21 से रहस्यमय संख्या "-1" लूप निष्पादन के लिए बूलियन स्थिति से जुड़ी हुई है (मैंने दुर्घटना के बाद लगभग इसे खोज लिया था)।

LumaValue कोशिकाओं और स्वयं LumaValue से पिक्सेल की संख्या प्राप्त करने के बाद, हम दूसरे चक्र पर आगे बढ़ सकते हैं।

दूसरे चक्र का कार्य पिक्सेल के प्रभाव और औसत चमक की गणना करना है।

हम पहले लूप में गणना किए गए lumaValue से शुरू करते हैं।

float finalAvgLuminance = 0.0f;

//
uint numProcessedPixelStart = numProcessedPixels;

// - .
// , , lumaValue.
// [0-255], , , ,
// pixelsToConsiderEnd.
// .
bExitLoop = false;
[loop]
while (!bExitLoop)
{
// .
uint numPixels = shared_data[lumaValue];

//
numProcessedPixels += numPixels;

// , [0-255] (uint)
uint encodedLumaUint = lumaValue;

//
float numberOfPixelsWithCurrentLuma = numPixels;

// , [0-255] (float)
float encodedLumaFloat = encodedLumaUint;

इस स्तर पर, हमने अंतराल [0.0f-255.f] में एन्कोडेड चमक मूल्य प्राप्त किया।

डिकोडिंग प्रक्रिया काफी सरल है - आपको एन्कोडिंग चरण की गणना को उल्टा करने की आवश्यकता है।

कोडिंग प्रक्रिया का एक संक्षिप्त दोहराव:

float luma = dot( hdrPixelColor, float3(0.2126, 0.7152, 0.0722) );
...
float outLuma;

// log(0) undef, log(1) = 0
outLuma = luma + 1.0;

//
outLuma = log( outLuma );

// 128, log(1) * 128 = 0, log(2,71828) * 128 = 128, log(7,38905) * 128 = 256
outLuma = outLuma * 128

// uint
uint outLumaUint = min( (uint) outLuma, 255);

चमक को डिकोड करने के लिए, हम एन्कोडिंग प्रक्रिया को उल्टा करते हैं, उदाहरण के लिए, इस तरह:

// 0.5f ( , )
float fDecodedLuma = encodedLumaFloat + 0.5;

// :

// 128
fDecodedLuma /= 128.0;

// exp(x), log(x)
fDecodedLuma = exp(fDecodedLuma);

// 1.0
fDecodedLuma -= 1.0;

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

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

यहाँ बाकी लूप (और shader) है: पूरा shader यहाँ उपलब्ध है । यह मेरे HLSLexplorer कार्यक्रम के साथ पूरी तरह से संगत है , जिसके बिना मैं प्रभावी रूप से द विचर 3 (और अन्य सभी प्रभाव भी!) में औसत चमक गणना को फिर से बनाने में सक्षम नहीं होगा। निष्कर्ष में, कुछ विचार। औसत चमक की गणना करने के संदर्भ में, इस शेडर को फिर से बनाना मुश्किल था। मुख्य कारण: 1) चक्र के निष्पादन पर अजीब "लंबित" चेक, मुझे पहले से सोचा गया था कि यह बहुत अधिक समय लगा। 2) रेंडरडोक (v। 1.2) में इस कम्प्यूटेशनल शेडर को डीबग करने में समस्या।

//
float fCurrentLumaContribution = numberOfPixelsWithCurrentLuma * fDecodedLuma;

// () .
float tempTotalContribution = fCurrentLumaContribution + finalAvgLuminance;


[flatten]
if (numProcessedPixels > pixelsToConsiderEnd )
{
//
bExitLoop = true;

// , .
//
int diff = numProcessedPixels - numProcessedPixelStart;

//
finalAvgLuminance = tempTotalContribution / float(diff);
}
else
{
// lumaValue
finalAvgLuminance = tempTotalContribution;
lumaValue++;
}
}

//
g_avgLuminance[uint2(0,0)] = finalAvgLuminance;









ऑपरेशन "ld_structured_indexable" पूरी तरह से समर्थित नहीं हैं, हालांकि सूचकांक 0 से पढ़ने का परिणाम सही मूल्य देता है, अन्य सभी शून्य वापस लौटते हैं, यही वजह है कि चक्र अनिश्चित काल तक जारी रहता है।

हालाँकि, मैं मूल के समान कोडांतरक (अंतर के लिए नीचे स्क्रीनशॉट देखें) प्राप्त करने में सक्षम नहीं था, RenderDoc का उपयोग करके मैं इस shader को पाइपलाइन में इंजेक्ट करने में सक्षम था - और परिणाम समान थे!


लड़ाई का नतीजा। बाईं ओर मेरा shader है, दाईं ओर मूल कोडांतरक कोड है।

भाग 8. चंद्रमा और उसके चरण

लेख के आठवें भाग में, मैं द विचर 3 (और विशेष रूप से, रक्त और शराब के विस्तार से) से चंद्रमा की छाया की जांच करता हूं।

चाँद रात के आकाश का एक महत्वपूर्ण तत्व है, और इसे विश्वसनीय बनाना मुश्किल हो सकता है, लेकिन मेरे लिए रात में TW3 में चलना एक वास्तविक आनंद था।

जरा इस दृश्य को देखें!


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

यह सुनिश्चित करें कि चंद्रमा दूरदराज के विमान, खेतों और MinDepth MaxDepth संरचना पर पूरी तरह से निहित D3D11_VIEWPORT मूल्य 0.0 (एक ही चाल है कि आकाश गुंबद के लिए इस्तेमाल किया गया था) सौंपा। आकाश के तुरंत बाद चंद्रमा का प्रतिपादन किया जाता है।


गोला चाँद को खींचने के लिए इस्तेमाल किया गया।

खैर, सब कुछ, मुझे लगता है, आप आगे बढ़ सकते हैं। आइए पिक्सेल shader पर एक नज़र डालें: मुख्य कारण है कि मैंने ब्लड और वाइन से एक शेडर चुना है - यह छोटा है। सबसे पहले, हम बनावट को नमूना करने के लिए ऑफसेट की गणना करते हैं। cb0 [0] .w का उपयोग X अक्ष के साथ एक ऑफसेट के रूप में किया जाता है। इस सरल चाल से हम चंद्रमा के घूर्णन को अपनी धुरी के चारों ओर घुमा सकते हैं।

ps_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb0[1], immediateIndexed
dcl_constantbuffer cb2[3], immediateIndexed
dcl_constantbuffer cb12[267], immediateIndexed
dcl_sampler s0, mode_default
dcl_resource_texture2d (float,float,float,float) t0
dcl_input_ps linear v1.w
dcl_input_ps linear v2.xyzw
dcl_input_ps linear v3.xy
dcl_input_ps linear v4.xy
dcl_output o0.xyzw
dcl_temps 3
0: mov r0.x, -cb0[0].w
1: mov r0.y, l(0)
2: add r0.xy, r0.xyxx, v2.xyxx
3: sample_indexable(texture2d)(float,float,float,float) r0.xyzw, r0.xyxx, t0.xyzw, s0
4: add r0.xyz, r0.xyzx, l(-0.500000, -0.500000, -0.500000, 0.000000)
5: log r0.w, r0.w
6: mul r0.w, r0.w, l(2.200000)
7: exp r0.w, r0.w
8: add r0.xyz, r0.xyzx, r0.xyzx
9: dp3 r1.x, r0.xyzx, r0.xyzx
10: rsq r1.x, r1.x
11: mul r0.xyz, r0.xyzx, r1.xxxx
12: mul r1.xy, r0.yyyy, v3.xyxx
13: mad r0.xy, v4.xyxx, r0.xxxx, r1.xyxx
14: mad r0.xy, v2.zwzz, r0.zzzz, r0.xyxx
15: mad r0.z, cb0[0].y, l(0.033864), cb0[0].w
16: mul r0.z, r0.z, l(6.283185)
17: sincos r1.x, r2.x, r0.z
18: mov r2.y, r1.x
19: dp2_sat r0.x, r0.xyxx, r2.xyxx
20: mul r0.xyz, r0.xxxx, cb12[266].xyzx
21: mul r0.xyz, r0.xyzx, r0.wwww
22: mul r0.xyz, r0.xyzx, cb2[2].xyzx
23: add_sat r0.w, -v1.w, l(1.000000)
24: mul r0.w, r0.w, cb2[2].w
25: mul o0.xyz, r0.wwww, r0.xyzx
26: mov o0.w, l(0)
27: ret








निरंतर बफर से मूल्यों के उदाहरण।

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


एक बनावट का अल्फा चैनल चंद्रमा की सतह का रंग है।


बनावट आरजीबी चैनल एक सामान्य नक्शा हैं।

सही बनावट निर्देशांक प्राप्त करने के बाद, हम RGBA चैनलों का नमूना लेते हैं। हमें सामान्य मानचित्र को अनपैक करने और सतह के रंग के गामा सुधार करने की आवश्यकता है। वर्तमान में, एक एचएलएसएल शेडर को इस तरह से लिखा जा सकता है, उदाहरण के लिए: अगला कदम एक सामान्य बाध्यकारी प्रदर्शन करना है, लेकिन केवल एक्सवाई घटकों में। (द विचर 3 में, जेड अक्ष ऊपर है, और बनावट का पूरा जेड-चैनल 1.0 है)। हम इसे इस तरह से कर सकते हैं: अब यह इस shader के मेरे पसंदीदा भाग के लिए समय है। 15-16 की तर्ज पर फिर से देखें : यह रहस्यमय 0.033864 क्या है? सबसे पहले, ऐसा लगता है कि इसका कोई मतलब नहीं है, लेकिन अगर हम इसके विपरीत मूल्य की गणना करते हैं, तो हमें लगभग 29.53 मिलते हैं, जो कि समान महीने की अवधि के बराबर है

float4 MoonPS(in InputStruct IN) : SV_Target0
{
// Texcoords
float2 uvOffsets = float2(-cb0_v0.w, 0.0);

// texcoords
float2 uv = IN.param2.xy + uvOffsets;

//
float4 sampledTexture = texture0.Sample( sampler0, uv);

// - -
float moonColorTex = pow(sampledTexture.a, 2.2 );

// [0,1] [-1,1].
// : sampledTexture.xyz * 2.0 - 1.0
float3 sampledNormal = normalize((sampledTexture.xyz - 0.5) * 2);



//
float3 Tangent = IN.param4.xyz;
float3 Normal = float3(IN.param2.zw, IN.param3.w);
float3 Bitangent = IN.param3.xyz;

// TBN
float3x3 TBN = float3x3(Tangent, Bitangent, Normal);

// XY
// TBN float3x2: 3 , 2
float2 vNormal = mul(sampledNormal, (float3x2)TBN).xy;



15: mad r0.z, cb0[0].y, l(0.033864), cb0[0].w
16: mul r0.z, r0.z, l(6.283185)

दिनों में! यह वही है जो मैं विस्तार से ध्यान देता हूं!

हम मज़बूती से यह मान सकते हैं कि cb0 [0]। यह उन दिनों की संख्या है जो गेमप्ले के दौरान बीत चुके हैं। एक अतिरिक्त विचलन का उपयोग यहां किया जाता है, जिसका उपयोग बनावट के एक्स-अक्ष के साथ ऑफसेट के रूप में किया जाता है।

इस गुणांक को प्राप्त करने के बाद, हम इसे 2 * पाई से गुणा करते हैं।

फिर sincos का उपयोग करके हम एक और 2d वेक्टर की गणना करते हैं।

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

// .
// days/29.53 + bias.
float phase = cb0_v0.y * (1.0 / SYNODIC_MONTH_LENGTH) + cb0_v0.w;

// 2*PI. , 29.53
// sin/cos.
phase *= TWOPI;

// .
float outSin = 0.0;
float outCos = 0.0;
sincos(phase, outSin, outCos);

//
float lunarPhase = saturate( dot(vNormal, float2(outCos, outSin)) );





अंतिम चरण अंतिम रंग की गणना करने के लिए गुणा संचालन की एक श्रृंखला करना है। आप शायद यह नहीं समझ पाएंगे कि यह शेडर आउटपुट के लिए 0.0 का अल्फा मान क्यों भेजता है। ऐसा इसलिए है क्योंकि चंद्रमा को सम्मिश्रण के साथ प्रदान किया गया है:

// .

// cb12_v266.xyz , .
// (1.54, 2.82, 4.13)
float3 moonSurfaceGlowColor = cb12_v266.xyz;

float3 moonColor = lunarPhase * moonSurfaceGlowColor;
moonColor = moonColorTex * moonColor;

// cb_v2.xyz - , , , (1.0, 1.0, 1.0)
moonColor *= cb2_v2.xyz;

// , , . - .
// , ,
// .
float paramHorizon = saturate(1.0 - IN.param1.w);
paramHorizon *= cb2_v2.w;

moonColor *= paramHorizon;

//
return float4(moonColor, 0.0);




यह दृष्टिकोण आपको पृष्ठभूमि (आकाश) रंग प्राप्त करने की अनुमति देता है यदि यह शेडर काला लौटता है।

यदि आप एक पूर्ण shader में रुचि रखते हैं, तो आप इसे यहाँ ले जा सकते हैं । इसमें बड़े निरंतर बफ़र्स हैं और पहले से ही मूल shader के बजाय RenderDoc में इंजेक्शन के लिए तैयार होना चाहिए (बस "MoonPS" का नाम बदलकर "EditedShaderPS")।

और आखिरी: मैं आपके साथ परिणाम साझा करना चाहता था:

बाईं ओर मेरा shader है, दाईं ओर खेल से मूल shader है।

अंतर न्यूनतम है और परिणामों को प्रभावित नहीं करता है।


जैसा कि आप देख सकते हैं, इस shader को बहलाना बहुत आसान था।

भाग 9. जी-बफर

इस भाग में, मैं The Witcher 3 में gbuffer के कुछ विवरणों को प्रकट करूँगा।

हम मानेंगे कि आप आस्थगित छायांकन की मूल बातें जानते हैं।

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

पहले (ज्यामिति पास) में हम सतह डेटा (स्थिति, मानक, स्पेक्युलर रंग, आदि ...) के साथ GBuffer को भरते हैं, और दूसरे (लाइटिंग पास) में हम सब कुछ गठबंधन करते हैं और प्रकाश की गणना करते हैं।

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

सीधे शब्दों में कहें, GBuffer ज्यामिति गुणों के साथ बनावट का एक सेट है। इसके लिए सही संरचना बनाना बहुत महत्वपूर्ण है। वास्तविक जीवन से एक उदाहरण के रूप में, आप Crysis 3 प्रतिपादन प्रौद्योगिकी का अध्ययन कर सकते हैं ।

इस संक्षिप्त परिचय के बाद, आइए द विचर 3: ब्लड एंड वाइन से एक उदाहरण फ्रेम देखें:


Toussent

Basic GBuffer के कई होटलों में से एक में DXGI_FORMAT_R8G8B8A8_UNORM प्रारूप में तीन पूर्ण-स्क्रीन रेंडर लक्ष्य और DXGI -FORMAT_D24_UNORM_S8_UINT प्रारूप में गहराई बफर + स्टैंसिल शामिल हैं।

यहाँ उनके स्क्रीनशॉट हैं:


रेंडर टारगेट 0 - आरजीबी चैनल, सतह का रंग


रेंडर टारगेट 0 - अल्फा चैनल। ईमानदारी से, मुझे नहीं पता कि यह जानकारी क्या है।


रेंडर टारगेट 1 - RGB चैनल। अंतराल में सामान्य वैक्टर [0-1] यहां दर्ज किए गए हैं।


रेंडर टारगेट 1 - अल्फा चैनल। परावर्तन जैसा दिखता है!


रेंडर टारगेट 2 - RGB चैनल। लग रहा है स्पेक्युलर कलर!

इस दृश्य में, अल्फा चैनल काला है (लेकिन बाद में इसका उपयोग किया जाता है)।


बफ़र की गहराई। ध्यान दें कि उल्टे गहराई का उपयोग यहां किया जाता है।


स्टैंसिल बफर का उपयोग एक विशिष्ट प्रकार के पिक्सेल को चिह्नित करने के लिए किया जाता है (उदाहरण के लिए, त्वचा, वनस्पति, आदि)

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

पोस्ट के "मुख्य" भाग पर आगे बढ़ने से पहले, मैं सामान्य अवलोकन दूंगा:

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

1) केवल बफर को साफ किया जाना गहराई / स्टैंसिल बफर है।

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

यही है, वास्तव में, RenderTarget1 इस तरह दिखता है (ध्यान दें कि "सबसे दूर के विमान पर धुंधले"):


यह एक सरल और स्मार्ट अनुकूलन है।

एक महत्वपूर्ण सबक: आपको ClearRenderTargetView कॉल पर संसाधन खर्च करने की आवश्यकता है, इसलिए आवश्यक होने पर ही उनका उपयोग करें।

2) उलटा गहराई - यह शांत है

में कई लेख पहले से ही लिखा चल बिन्दु के साथ गहराई बफर की सटीकता के बारे। विचर 3 उलट-जेड का उपयोग करता है। लंबी खुली दूरी के साथ इस तरह के खुले विश्व खेल के लिए यह प्राकृतिक विकल्प है।

डायरेक्टएक्स पर स्विच करना मुश्किल नहीं होगा:

ए) हम "0" लिखकर गहराई बफर को साफ करते हैं, न कि "1"।

पारंपरिक दृष्टिकोण में, गहराई बफर को साफ करने के लिए "1" मूल्य का उपयोग किया गया था। गहराई से फ़्लिप के बाद, नया "दूर" मान 0 हो गया, इसलिए आपको सब कुछ बदलने की आवश्यकता है।

ख) प्रोजेक्शन मैट्रिक्स की गणना करते समय निकट और दूर की सीमाओं की अदला-बदली करें।

सी)

ओपन चेक को "कम" से "अधिक" में बदलें। ओपनजीएल के लिए, थोड़ा और काम किया जाना चाहिए (ऊपर वर्णित लेख देखें), लेकिन यह इसके लायक है।

3) हम दुनिया में अपना स्थान नहीं रखते हैं।

हाँ, सब कुछ इतना सरल है। प्रकाश व्यवस्था के मार्ग में, हम गहराई से दुनिया में एक स्थिति को फिर से बनाते हैं।

पिक्सेल shader

इस भाग में, मैं वास्तव में पिक्सेल शेडर दिखाना चाहता था जो GBuffer को सतह डेटा की आपूर्ति करता है।

तो अब हम पहले से ही जानते हैं कि रंग, मानदंडों और स्पेक्युलर को कैसे स्टोर किया जाए।

बेशक, सब कुछ उतना सरल नहीं है जितना आप सोच सकते हैं।

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

विश्लेषण के लिए, मैंने इस सुंदर बैरल का उपयोग करने का फैसला किया:


हमारे वीर प्रति बैरल!

कृपया बनावट का स्वागत करें:


तो हमारे पास अल्बेडो है, एक सामान्य नक्शा है, और स्पेक्युलर रंग है। सुंदर मानक मामला।

शुरू करने से पहले, ज्यामिति इनपुट के बारे में कुछ शब्द:

ज्यामिति को स्थिति, टेक्सकोर्ड्स, सामान्य और स्पर्शरेखा बफ़र्स के साथ प्रेषित किया जाता है।

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

असेंबलर कोड में पिक्सेल shader: एक shader में कई चरण होते हैं। मैं इस shader के प्रत्येक प्रमुख भाग का अलग से वर्णन करूँगा।

ps_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb4[3], immediateIndexed
dcl_sampler s0, mode_default
dcl_sampler s13, mode_default
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_resource_texture2d (float,float,float,float) t13
dcl_input_ps linear v0.zw
dcl_input_ps linear v1.xyzw
dcl_input_ps linear v2.xyz
dcl_input_ps linear v3.xyz
dcl_input_ps_sgv v4.x, isfrontface
dcl_output o0.xyzw
dcl_output o1.xyzw
dcl_output o2.xyzw
dcl_temps 3
0: sample_indexable(texture2d)(float,float,float,float) r0.xyzw, v1.xyxx, t1.xyzw, s0
1: sample_indexable(texture2d)(float,float,float,float) r1.xyz, v1.xyxx, t0.xyzw, s0
2: add r1.w, r1.y, r1.x
3: add r1.w, r1.z, r1.w
4: mul r2.x, r1.w, l(0.333300)
5: add r2.y, l(-1.000000), cb4[1].x
6: mul r2.y, r2.y, l(0.500000)
7: mov_sat r2.z, r2.y
8: mad r1.w, r1.w, l(-0.666600), l(1.000000)
9: mad r1.w, r2.z, r1.w, r2.x
10: mul r2.xzw, r1.xxyz, cb4[0].xxyz
11: mul_sat r2.xzw, r2.xxzw, l(1.500000, 0.000000, 1.500000, 1.500000)
12: mul_sat r1.w, abs(r2.y), r1.w
13: add r2.xyz, -r1.xyzx, r2.xzwx
14: mad r1.xyz, r1.wwww, r2.xyzx, r1.xyzx
15: max r1.w, r1.z, r1.y
16: max r1.w, r1.w, r1.x
17: lt r1.w, l(0.220000), r1.w
18: movc r1.w, r1.w, l(-0.300000), l(-0.150000)
19: mad r1.w, v0.z, r1.w, l(1.000000)
20: mul o0.xyz, r1.wwww, r1.xyzx
21: add r0.xyz, r0.xyzx, l(-0.500000, -0.500000, -0.500000, 0.000000)
22: add r0.xyz, r0.xyzx, r0.xyzx
23: mov r1.x, v0.w
24: mov r1.yz, v1.zzwz
25: mul r1.xyz, r0.yyyy, r1.xyzx
26: mad r1.xyz, v3.xyzx, r0.xxxx, r1.xyzx
27: mad r0.xyz, v2.xyzx, r0.zzzz, r1.xyzx
28: uge r1.x, l(0), v4.x
29: if_nz r1.x
30: dp3 r1.x, v2.xyzx, r0.xyzx
31: mul r1.xyz, r1.xxxx, v2.xyzx
32: mad r0.xyz, -r1.xyzx, l(2.000000, 2.000000, 2.000000, 0.000000), r0.xyzx
33: endif
34: sample_indexable(texture2d)(float,float,float,float) r1.xyz, v1.xyxx, t2.xyzw, s0
35: max r1.w, r1.z, r1.y
36: max r1.w, r1.w, r1.x
37: lt r1.w, l(0.200000), r1.w
38: movc r2.xyz, r1.wwww, r1.xyzx, l(0.120000, 0.120000, 0.120000, 0.000000)
39: add r2.xyz, -r1.xyzx, r2.xyzx
40: mad o2.xyz, v0.zzzz, r2.xyzx, r1.xyzx
41: lt r1.x, r0.w, l(0.330000)
42: mul r1.y, r0.w, l(0.950000)
43: movc r1.x, r1.x, r1.y, l(0.330000)
44: add r1.x, -r0.w, r1.x
45: mad o1.w, v0.z, r1.x, r0.w
46: dp3 r0.w, r0.xyzx, r0.xyzx
47: rsq r0.w, r0.w
48: mul r0.xyz, r0.wwww, r0.xyzx
49: max r0.w, abs(r0.y), abs(r0.x)
50: max r0.w, r0.w, abs(r0.z)
51: lt r1.xy, abs(r0.zyzz), r0.wwww
52: movc r1.yz, r1.yyyy, abs(r0.zzyz), abs(r0.zzxz)
53: movc r1.xy, r1.xxxx, r1.yzyy, abs(r0.yxyy)
54: lt r1.z, r1.y, r1.x
55: movc r1.xy, r1.zzzz, r1.xyxx, r1.yxyy
56: div r1.z, r1.y, r1.x
57: div r0.xyz, r0.xyzx, r0.wwww
58: sample_l(texture2d)(float,float,float,float) r0.w, r1.xzxx, t13.yzwx, s13, l(0)
59: mul r0.xyz, r0.wwww, r0.xyzx
60: mad o1.xyz, r0.xyzx, l(0.500000, 0.500000, 0.500000, 0.000000), l(0.500000, 0.500000, 0.500000, 0.000000)
61: mov o0.w, cb4[2].x
62: mov o2.w, l(0)
63: ret



लेकिन सबसे पहले, हमेशा की तरह - निरंतर बफर से मूल्यों के साथ एक स्क्रीनशॉट:

albedo

हम जटिल चीजों से शुरुआत करेंगे। यह सिर्फ "OutputColor.rgb = Texture.Sample (uv) .rgb" नहीं

है RGB रंग बनावट (पंक्ति 1) के नमूने के बाद, अगली 14 पंक्तियाँ हैं जिन्हें मैं "संतृप्ति कमी बफर" कहता हूं। मुझे आपको एचएलएसएल कोड दिखाते हैं: अधिकांश वस्तुओं के लिए, यह कोड बनावट के मूल रंग के अलावा कुछ नहीं करता है। यह इसी "भौतिक cbuffer" मूल्यों द्वारा प्राप्त किया जाता है। cb4_v1.x का मान 1.0 है, जो 0.0 का मास्क देता है और लेरप निर्देश से इनपुट रंग देता है । हालाँकि, कुछ अपवाद हैं। मुझे मिला सबसे बड़ा desaturationFactor 4.0 है (यह 1.0 से कम कभी नहीं है), और desaturatedColor

float3 albedoColorFilter( in float3 color, in float desaturationFactor, in float3 desaturationValue )
{
float sumColorComponents = color.r + color.g + color.b;

float averageColorComponentValue = 0.3333 * sumColorComponents;
float oneMinusAverageColorComponentValue = 1.0 - averageColorComponentValue;

float factor = 0.5 * (desaturationFactor - 1.0);

float avgColorComponent = lerp(averageColorComponentValue, oneMinusAverageColorComponentValue, saturate(factor));
float3 desaturatedColor = saturate(color * desaturationValue * 1.5);

float mask = saturate( avgColorComponent * abs(factor) );

float3 finalColor = lerp( color, desaturatedColor, mask );
return finalColor;
}



सामग्री पर निर्भर करता है। यह कुछ ऐसा हो सकता है (0.2, 0.3, 0.4); कोई सख्त नियम नहीं हैं। बेशक, मैं अपने खुद के DX11 ढांचे में इसे लागू करने का विरोध नहीं कर सका, और यहां ऐसे परिणाम हैं जहां सभी desaturatedColor मान फ्लोट 3 (0.25, 0.3, 0.45) के बराबर हैं


desaturationFactor = 1.0 (कोई प्रभाव नहीं है)


desaturationFactor = 2.0


desaturationFactor = 3.0


desaturationFactor = 4.0

मुझे यकीन है कि यह केवल भौतिक मापदंडों का एक अनुप्रयोग है, लेकिन एल्बिडो भाग के अंत में प्रदर्शन नहीं किया गया है।

लाइनें 15-20 अंतिम स्पर्शों को जोड़ती हैं : v0.z शीर्ष छायाकर्ता से आउटपुट है, और वे शून्य हैं। इसके बारे में मत भूलना, क्योंकि v0.z बाद में कई बार उपयोग किया जाएगा। ऐसा लगता है कि यह किसी प्रकार का गुणांक है, और पूरा कोड थोड़ा कमिंग अल्बेडो जैसा दिखता है, लेकिन चूंकि v0.z 0 है, रंग अपरिवर्तित रहता है। HLSL: RT0.a के बारे में, जैसा कि हम देख सकते हैं, यह सामग्री निरंतर बफर से ली गई है, लेकिन चूंकि shader में डिबगिंग की कोई जानकारी नहीं है, इसलिए यह कहना मुश्किल है कि यह क्या है। शायद पारभासी? हम पहले प्रस्तुत लक्ष्य के साथ कर रहे हैं!

15: max r1.w, r1.z, r1.y
16: max r1.w, r1.w, r1.x
17: lt r1.w, l(0.220000), r1.w
18: movc r1.w, r1.w, l(-0.300000), l(-0.150000)
19: mad r1.w, v0.z, r1.w, l(1.000000)
20: mul o0.xyz, r1.wwww, r1.xyzx





/* ALBEDO */
// (?)
float3 albedoColor = albedoColorFilter( colorTex, cb4_v1.x, cb4_v0.rgb );
float albedoMaxComponent = getMaxComponent( albedoColor );

// ,
// "paramZ" 0
float paramZ = Input.out0.z; // , 0

// , 0.70 0.85
// lerp, .
float param = (albedoMaxComponent > 0.22) ? 0.70 : 0.85;
float mulParam = lerp(1, param, paramZ);

//
pout.RT0.rgb = albedoColor * mulParam;
pout.RT0.a = cb4_v2.x;

normals

आइए सामान्य मानचित्र को अनपैक करके शुरू करें, और फिर, हमेशा की तरह, हम मानदंडों को बांधेंगे: अभी तक, आश्चर्य की बात नहीं है। 28-33 की पंक्तियों को देखें: हम मोटे तौर पर उन्हें इस प्रकार लिख सकते हैं: यकीन नहीं होता कि यह लिखना सही है। यदि आप जानते हैं कि यह गणितीय ऑपरेशन क्या है, तो मुझे बताएं। हम देखते हैं कि पिक्सेल shader SV_IsFrontFace का उपयोग करता है।

/* */
float3 sampledNormal = ((normalTex.xyz - 0.5) * 2);

// TBN
float3 Tangent = Input.TangentW.xyz;
float3 Normal = Input.NormalW.xyz;
float3 Bitangent;
Bitangent.x = Input.out0.w;
Bitangent.yz = Input.out1.zw;

// ; , , normal-tbn
// 'mad' 'mov'
Bitangent = saturate(Bitangent);

float3x3 TBN = float3x3(Tangent, Bitangent, Normal);
float3 normal = mul( sampledNormal, TBN );





28: uge r1.x, l(0), v4.x
29: if_nz r1.x
30: dp3 r1.x, v2.xyzx, r0.xyzx
31: mul r1.xyz, r1.xxxx, v2.xyzx
32: mad r0.xyz, -r1.xyzx, l(2.000000, 2.000000, 2.000000, 0.000000), r0.xyzx
33: endif



[branch] if (bIsFrontFace <= 0)
{
float cosTheta = dot(Input.NormalW, normal);
float3 invNormal = cosTheta * Input.NormalW;
normal = normal - 2*invNormal;
}





यह क्या हैप्रलेखन मदद के लिए आता है (मैं "msdn" लिखना चाहता था, लेकिन ...):

निर्धारित करता है कि त्रिकोण कैमरे को देख रहा है या नहीं। लाइनों और बिंदुओं के लिए, IsFrontFace सच है। एक अपवाद त्रिकोण (वायरफ्रेम मोड) से खींची गई रेखाएं हैं, जो ठोस मोड में एक त्रिभुज को रेखापुंज करने के लिए IsFrontFace को समान रूप से सेट करती हैं। इसे लिखना एक ज्यामिति shader द्वारा किया जा सकता है, और इसे पिक्सेल shader द्वारा पढ़ा जा सकता है।

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

यहाँ एक तुलना है: दोनों दृश्य के फ्रेम के रंग इस चाल के साथ / बंद, साथ ही साथ gbuffer की बनावट [0-1] मानदंडों के साथ चाल / बंद:


बिना छल के दृश्य का रंग


स्टंट के साथ रंग दृश्य


सामान्य [0-1] कोई चाल नहीं


एक चाल के साथ सामान्य [0-1]

क्या आपने देखा है कि GBuffer में प्रत्येक रेंडर लक्ष्य R8G8B8A8_UNORM प्रारूप है? इसका मतलब है कि प्रति घटक 256 संभावित मूल्य हैं। क्या यह मानदंडों को संग्रहीत करने के लिए पर्याप्त है?

Gbuffer में पर्याप्त बाइट्स के साथ उच्च गुणवत्ता वाले मानदंडों को संग्रहीत करना एक ज्ञात मुद्दा है, लेकिन सौभाग्य से सीखने के लिए कई अलग-अलग सामग्रियां हैं ।

शायद आप में से कुछ पहले से ही जानते हैं कि यहां किस तकनीक का उपयोग किया जाता है। मुझे कहना होगा कि ज्यामिति के पूरे मार्ग में स्लॉट 13 से जुड़ी एक अतिरिक्त बनावट है ...:



हा!The Witcher 3 एक तकनीक का उपयोग करता है जिसे " बेस्ट फिट नॉर्म्स " कहा जाता है । यहां मैं इसे विस्तार से नहीं बताऊंगा (प्रस्तुति देखें)। इसका आविष्कार क्रायटेक द्वारा 2009-2010 के आसपास किया गया था, और चूंकि क्राय्वेनइन का खुला स्रोत है, बीएफएन भी खुला स्रोत है ।

BFN मानदंडों की बनावट को "दानेदार" रूप देता है।

बीएफएन का उपयोग करते हुए मानदंडों को स्केल करने के बाद, हम उन्हें अंतराल [-1; 1] से [0, 1] तक फिर से बनाते हैं।

स्पेक्युलर

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

34: sample_indexable(texture2d)(float,float,float,float) r1.xyz, v1.xyxx, t2.xyzw, s0
35: max r1.w, r1.z, r1.y
36: max r1.w, r1.w, r1.x
37: lt r1.w, l(0.200000), r1.w
38: movc r2.xyz, r1.wwww, r1.xyzx, l(0.120000, 0.120000, 0.120000, 0.000000)
39: add r2.xyz, -r1.xyzx, r2.xyzx
40: mad o2.xyz, v0.zzzz, r2.xyzx, r1.xyzx







/* SPECULAR */
float3 specularTex = texture2.Sample( samplerAnisoWrap, Texcoords ).rgb;

// , Albedo. . ,
// - "".
// paramZ 0,
// .
float specularMaxComponent = getMaxComponent( specularTex );
float3 specB = (specularMaxComponent > 0.2) ? specularTex : float3(0.12, 0.12, 0.12);
float3 finalSpec = lerp(specularTex, specB, paramZ);
pout.RT2.xyz = finalSpec;

की क्षमता को दर्शाती है

मुझे पता नहीं है कि क्या यह नाम इस पैरामीटर के लिए उपयुक्त है, क्योंकि मुझे नहीं पता कि यह प्रकाश के पारित होने को कैसे प्रभावित करता है। तथ्य यह है कि इनपुट सामान्य नक्शे के अल्फा चैनल में अतिरिक्त डेटा है:


अल्फा चैनल बनावट "सामान्य नक्शा"।

कोडांतरक कोड: हमारे पुराने मित्र को नमस्ते कहें - v0.z! इसका अर्थ अल्बेडो और स्पेकुलर के समान है:

41: lt r1.x, r0.w, l(0.330000)
42: mul r1.y, r0.w, l(0.950000)
43: movc r1.x, r1.x, r1.y, l(0.330000)
44: add r1.x, -r0.w, r1.x
45: mad o1.w, v0.z, r1.x, r0.w



/* REFLECTIVITY */
float reflectivity = normalTex.a;
float reflectivity2 = (reflectivity < 0.33) ? (reflectivity * 0.95) : 0.33;

float finalReflectivity = lerp(reflectivity, reflectivity2, paramZ);
pout.RT1.a = finalReflectivity;

बहुत बढ़िया!यह पिक्सेल shader के पहले संस्करण के विश्लेषण का अंत है।

यहाँ मूल (दाएं) के साथ मेरे shader (बाएं) की तुलना है:


ये अंतर गणनाओं को प्रभावित नहीं करते हैं, इसलिए यहां मेरा काम समाप्त हो गया है।

पिक्सेल शेडर: अलबेडो + सामान्य विकल्प

मैंने एक और विकल्प दिखाने का फैसला किया, अब केवल एल्बेडो और सामान्य नक्शे के साथ, बिना स्पेकुलर बनावट के। कोडांतरक कोड थोड़ा लंबा है: इस और पिछले विकल्पों के बीच का अंतर निम्नानुसार है: ए) लाइनें 1, 19 : इंटरपोलेशन पैरामीटर v0.z को cb4 [0] .x से निरंतर बफर से गुणा किया जाता है, लेकिन यह उत्पाद केवल लाइन 19 पर इंटरपोलेशन अल्बेडो के लिए उपयोग किया जाता है। अन्य आउटपुट के लिए, v0.z के "सामान्य" मान का उपयोग किया जाता है। b) लाइनें 54-55 : o2.w अब इस शर्त के तहत निर्धारित की जाती हैं कि (cb4 [7] .x> 0.0) हम पहले से ही इस पैटर्न को "कुछ प्रकार की तुलना - और" चमक हिस्टोग्राम की गणना से पहचानते हैं। इसे इस तरह लिखा जा सकता है: सी) लाइनें 34-42 : पूरी तरह से अलग स्पेक्युलर गणना।

ps_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb4[8], immediateIndexed
dcl_sampler s0, mode_default
dcl_sampler s13, mode_default
dcl_resource_texture2d (float,float,float,float) t0
dcl_resource_texture2d (float,float,float,float) t1
dcl_resource_texture2d (float,float,float,float) t13
dcl_input_ps linear v0.zw
dcl_input_ps linear v1.xyzw
dcl_input_ps linear v2.xyz
dcl_input_ps linear v3.xyz
dcl_input_ps_sgv v4.x, isfrontface
dcl_output o0.xyzw
dcl_output o1.xyzw
dcl_output o2.xyzw
dcl_temps 4
0: mul r0.x, v0.z, cb4[0].x
1: sample_indexable(texture2d)(float,float,float,float) r1.xyzw, v1.xyxx, t1.xyzw, s0
2: sample_indexable(texture2d)(float,float,float,float) r0.yzw, v1.xyxx, t0.wxyz, s0
3: add r2.x, r0.z, r0.y
4: add r2.x, r0.w, r2.x
5: add r2.z, l(-1.000000), cb4[2].x
6: mul r2.yz, r2.xxzx, l(0.000000, 0.333300, 0.500000, 0.000000)
7: mov_sat r2.w, r2.z
8: mad r2.x, r2.x, l(-0.666600), l(1.000000)
9: mad r2.x, r2.w, r2.x, r2.y
10: mul r3.xyz, r0.yzwy, cb4[1].xyzx
11: mul_sat r3.xyz, r3.xyzx, l(1.500000, 1.500000, 1.500000, 0.000000)
12: mul_sat r2.x, abs(r2.z), r2.x
13: add r2.yzw, -r0.yyzw, r3.xxyz
14: mad r0.yzw, r2.xxxx, r2.yyzw, r0.yyzw
15: max r2.x, r0.w, r0.z
16: max r2.x, r0.y, r2.x
17: lt r2.x, l(0.220000), r2.x
18: movc r2.x, r2.x, l(-0.300000), l(-0.150000)
19: mad r0.x, r0.x, r2.x, l(1.000000)
20: mul o0.xyz, r0.xxxx, r0.yzwy
21: add r0.xyz, r1.xyzx, l(-0.500000, -0.500000, -0.500000, 0.000000)
22: add r0.xyz, r0.xyzx, r0.xyzx
23: mov r1.x, v0.w
24: mov r1.yz, v1.zzwz
25: mul r1.xyz, r0.yyyy, r1.xyzx
26: mad r0.xyw, v3.xyxz, r0.xxxx, r1.xyxz
27: mad r0.xyz, v2.xyzx, r0.zzzz, r0.xywx
28: uge r0.w, l(0), v4.x
29: if_nz r0.w
30: dp3 r0.w, v2.xyzx, r0.xyzx
31: mul r1.xyz, r0.wwww, v2.xyzx
32: mad r0.xyz, -r1.xyzx, l(2.000000, 2.000000, 2.000000, 0.000000), r0.xyzx
33: endif
34: add r0.w, -r1.w, l(1.000000)
35: log r1.xyz, cb4[3].xyzx
36: mul r1.xyz, r1.xyzx, l(2.200000, 2.200000, 2.200000, 0.000000)
37: exp r1.xyz, r1.xyzx
38: mad r0.w, r0.w, cb4[4].x, cb4[5].x
39: mul_sat r1.xyz, r0.wwww, r1.xyzx
40: log r1.xyz, r1.xyzx
41: mul r1.xyz, r1.xyzx, l(0.454545, 0.454545, 0.454545, 0.000000)
42: exp r1.xyz, r1.xyzx
43: max r0.w, r1.z, r1.y
44: max r0.w, r0.w, r1.x
45: lt r0.w, l(0.200000), r0.w
46: movc r2.xyz, r0.wwww, r1.xyzx, l(0.120000, 0.120000, 0.120000, 0.000000)
47: add r2.xyz, -r1.xyzx, r2.xyzx
48: mad o2.xyz, v0.zzzz, r2.xyzx, r1.xyzx
49: lt r0.w, r1.w, l(0.330000)
50: mul r1.x, r1.w, l(0.950000)
51: movc r0.w, r0.w, r1.x, l(0.330000)
52: add r0.w, -r1.w, r0.w
53: mad o1.w, v0.z, r0.w, r1.w
54: lt r0.w, l(0), cb4[7].x
55: and o2.w, r0.w, l(0.064706)
56: dp3 r0.w, r0.xyzx, r0.xyzx
57: rsq r0.w, r0.w
58: mul r0.xyz, r0.wwww, r0.xyzx
59: max r0.w, abs(r0.y), abs(r0.x)
60: max r0.w, r0.w, abs(r0.z)
61: lt r1.xy, abs(r0.zyzz), r0.wwww
62: movc r1.yz, r1.yyyy, abs(r0.zzyz), abs(r0.zzxz)
63: movc r1.xy, r1.xxxx, r1.yzyy, abs(r0.yxyy)
64: lt r1.z, r1.y, r1.x
65: movc r1.xy, r1.zzzz, r1.xyxx, r1.yxyy
66: div r1.z, r1.y, r1.x
67: div r0.xyz, r0.xyzx, r0.wwww
68: sample_l(texture2d)(float,float,float,float) r0.w, r1.xzxx, t13.yzwx, s13, l(0)
69: mul r0.xyz, r0.wwww, r0.xyzx
70: mad o1.xyz, r0.xyzx, l(0.500000, 0.500000, 0.500000, 0.000000), l(0.500000, 0.500000, 0.500000, 0.000000)
71: mov o0.w, cb4[6].x
72: ret









pout.RT2.w = (cb4_v7.x > 0.0) ? (16.5/255.0) : 0.0;



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

34: add r0.w, -r1.w, l(1.000000)
35: log r1.xyz, cb4[3].xyzx
36: mul r1.xyz, r1.xyzx, l(2.200000, 2.200000, 2.200000, 0.000000)
37: exp r1.xyz, r1.xyzx
38: mad r0.w, r0.w, cb4[4].x, cb4[5].x
39: mul_sat r1.xyz, r0.wwww, r1.xyzx
40: log r1.xyz, r1.xyzx
41: mul r1.xyz, r1.xyzx, l(0.454545, 0.454545, 0.454545, 0.000000)
42: exp r1.xyz, r1.xyzx



float oneMinusReflectivity = 1.0 - normalTex.a;
float3 specularTex = pow(cb4_v3.rgb, 2.2);
oneMinusReflectivity = oneMinusReflectivity * cb4_v4.x + cb4_v5.x;
specularTex = saturate(specularTex * oneMinusReflectivity);
specularTex = pow(specularTex, 1.0/2.2);

// ...
float specularMaxComponent = getMaxComponent( specularTex );
...

संक्षेप में देना

... और अगर आप इसे यहाँ पढ़ते हैं, तो आप शायद थोड़ा और गहराई में जाना चाहते हैं।

वास्तविक जीवन में जो सरल लगता है वह अक्सर ऐसा नहीं होता है, और gbuffer के लिए डेटा ट्रांसफर The Witcher 3 कोई अपवाद नहीं था। मैंने आपको इसके लिए जिम्मेदार पिक्सेल शेड के केवल सबसे सरल संस्करण दिखाए, और सामान्य अवलोकन भी दिए जो सामान्य रूप से स्थगित छायांकन से संबंधित हैं।

सबसे अधिक रोगी के लिए, पास्टबिन में पिक्सेल शेड के लिए दो विकल्प हैं:

विकल्प 1 - स्पेकुलर टेक्सचर के साथ

विकल्प 2 - स्पेक्युलर टेक्सचर के बिना

भाग 10. दूरी में बारिश के पर्दे

इस भाग में हम एक अद्भुत वायुमंडलीय प्रभाव देखेंगे जो मुझे वास्तव में पसंद है - क्षितिज के पास दूर की बारिश / हल्के पर्दे । खेल में, वे स्कीलिंग द्वीप पर मिलना आसान है।


व्यक्तिगत रूप से, मैं वास्तव में इस वायुमंडलीय घटना को पसंद करता हूं और उत्सुक था कि सीडी प्रॉजेक्ट रेड ग्राफिक्स प्रोग्रामर्स ने इसे कैसे लागू किया। चलो यह पता लगाने!

बारिश के पर्दे लगाने से पहले और बाद में यहां दो स्क्रीनशॉट दिए गए हैं:


बारिश के पर्दे तक


बारिश के पर्दे के बाद

ज्यामिति

सबसे पहले, हम ज्यामिति पर ध्यान केंद्रित करेंगे। एक छोटे सिलेंडर का उपयोग करने का विचार है:


स्थानीय अंतरिक्ष में एक सिलेंडर स्थानीय स्थान

में अपनी स्थिति के दृष्टिकोण से, यह काफी छोटा है - इसकी स्थिति सीमा में है (0.0 / 1.0)।

इस ड्रॉ कॉल के लिए इनपुट सर्किट इस तरह दिखता है ...


निम्नलिखित हमारे लिए यहाँ महत्वपूर्ण है: टेक्सकोर्डर्स और इंस्टेंस_ट्रांसफॉर्म।

टेक्सकोर्ड काफी सरलता से लिपटे हुए हैं: ऊपरी और निचले आधारों का यू अंतराल [0.02777 - 1.02734] में है। निचले आधार पर V 1.0 है, और ऊपरी - 0.0 पर। जैसा कि आप देख सकते हैं, आप काफी सरलता से इस जाल को बना सकते हैं।

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




बहुत डरावना लगता है, है ना? लेकिन चिंता मत करो, हम इस मैट्रिक्स का विश्लेषण करेंगे और देखेंगे कि यह क्या छुपाता है! परिणाम बहुत दिलचस्प हैं: इस विशेष फ्रेम में कैमरे की स्थिति जानना महत्वपूर्ण है: (-116.5338, 234.8695, 2.09) जैसा कि आप देख सकते हैं, हमने सिलेंडर को विश्व अंतरिक्ष में काफी बड़ा करने के लिए स्केल किया है (TW3- जेड अक्ष का निर्देशन किया गया है), इसे कैमरा स्थिति के सापेक्ष स्थानांतरित कर दिया है , और मुड़ा। यहां देखें कि सिलेण्डर शेडर के साथ रूपांतरण के बाद सिलेंडर कैसा दिखता है:

XMMATRIX mat( -227.7472, 159.8043, 374.0736, -116.4951,
-194.7577, -173.3836, -494.4982, 238.6908,
-14.16466, -185.4743, 784.564, -1.45565,
0.0, 0.0, 0.0, 1.0 );

mat = XMMatrixTranspose( mat );

XMVECTOR vScale;
XMVECTOR vRotateQuat;
XMVECTOR vTranslation;
XMMatrixDecompose( &vScale, &vRotateQuat, &vTranslation, mat );

// ...
XMMATRIX matRotate = XMMatrixRotationQuaternion( vRotateQuat );



vRotateQuat: (0.0924987569, -0.314900011, 0.883411944, -0.334462732)

vScale: (299.999969, 300.000000, 1000.00012)

vTranslation: (-116.495102, 238.690796, -1.45564997)








वर्टिकल शेडर द्वारा रूपांतरण के बाद सिलेंडर। देखें कि यह दृश्यता के पिरामिड के सापेक्ष कैसे स्थित है।

वर्टेक्स शेडर

इनपुट ज्यामिति और वर्टेकर शेडर एक दूसरे पर कड़ाई से निर्भर हैं।

आइए, वर्टिकल शेडर के लिए कोडांतरक कोड पर करीब से नज़र डालते हैं: सरल पासिंग टेक्सकोर्ड्स (लाइन 0) और इंस्टेंस_ओडी_पराम (लाइन 8) के साथ, आउटपुट के लिए दो और तत्वों की आवश्यकता होती है: SV_Position (यह स्पष्ट है) और दुनिया में स्थिति की ऊंचाई (घटक .z)। याद रखें कि स्थानीय स्थान [0-1] रेंज में है? इसलिए, विश्व मैट्रिक्स को लागू करने से ठीक पहले, वर्टेक्स शेडर स्थानीय स्थिति को बदलने के लिए पैमाने और विचलन का उपयोग करता है। स्मार्ट चाल! इस मामले में, स्केल = फ्लोट 3 (4, 4, 2), और बायस = फ्लोट 3 (-2, -1, -1)। < जो पैटर्न 9 और 28 के बीच ध्यान देने योग्य है, वह दो पंक्ति-प्रमुख परिपक्वताओं का गुणन है। आइए, एचएलएसएल पर तैयार वर्कट शेअर को देखें:

vs_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb1[7], immediateIndexed
dcl_constantbuffer cb2[6], immediateIndexed
dcl_input v0.xyz
dcl_input v1.xy
dcl_input v4.xyzw
dcl_input v5.xyzw
dcl_input v6.xyzw
dcl_input v7.xyzw
dcl_output o0.xyz
dcl_output o1.xyzw
dcl_output_siv o2.xyzw, position
dcl_temps 2
0: mov o0.xy, v1.xyxx
1: mul r0.xyzw, v5.xyzw, cb1[6].yyyy
2: mad r0.xyzw, v4.xyzw, cb1[6].xxxx, r0.xyzw
3: mad r0.xyzw, v6.xyzw, cb1[6].zzzz, r0.xyzw
4: mad r0.xyzw, cb1[6].wwww, l(0.000000, 0.000000, 0.000000, 1.000000), r0.xyzw
5: mad r1.xyz, v0.xyzx, cb2[4].xyzx, cb2[5].xyzx
6: mov r1.w, l(1.000000)
7: dp4 o0.z, r1.xyzw, r0.xyzw
8: mov o1.xyzw, v7.xyzw
9: mul r0.xyzw, v5.xyzw, cb1[0].yyyy
10: mad r0.xyzw, v4.xyzw, cb1[0].xxxx, r0.xyzw
11: mad r0.xyzw, v6.xyzw, cb1[0].zzzz, r0.xyzw
12: mad r0.xyzw, cb1[0].wwww, l(0.000000, 0.000000, 0.000000, 1.000000), r0.xyzw
13: dp4 o2.x, r1.xyzw, r0.xyzw
14: mul r0.xyzw, v5.xyzw, cb1[1].yyyy
15: mad r0.xyzw, v4.xyzw, cb1[1].xxxx, r0.xyzw
16: mad r0.xyzw, v6.xyzw, cb1[1].zzzz, r0.xyzw
17: mad r0.xyzw, cb1[1].wwww, l(0.000000, 0.000000, 0.000000, 1.000000), r0.xyzw
18: dp4 o2.y, r1.xyzw, r0.xyzw
19: mul r0.xyzw, v5.xyzw, cb1[2].yyyy
20: mad r0.xyzw, v4.xyzw, cb1[2].xxxx, r0.xyzw
21: mad r0.xyzw, v6.xyzw, cb1[2].zzzz, r0.xyzw
22: mad r0.xyzw, cb1[2].wwww, l(0.000000, 0.000000, 0.000000, 1.000000), r0.xyzw
23: dp4 o2.z, r1.xyzw, r0.xyzw
24: mul r0.xyzw, v5.xyzw, cb1[3].yyyy
25: mad r0.xyzw, v4.xyzw, cb1[3].xxxx, r0.xyzw
26: mad r0.xyzw, v6.xyzw, cb1[3].zzzz, r0.xyzw
27: mad r0.xyzw, cb1[3].wwww, l(0.000000, 0.000000, 0.000000, 1.000000), r0.xyzw
28: dp4 o2.w, r1.xyzw, r0.xyzw
29: ret











cbuffer cbPerFrame : register (b1)
{
row_major float4x4 g_viewProjMatrix;
row_major float4x4 g_rainShaftsViewProjMatrix;
}

cbuffer cbPerObject : register (b2)
{
float4x4 g_mtxWorld;
float4 g_modelScale;
float4 g_modelBias;
}

struct VS_INPUT
{
float3 PositionW : POSITION;
float2 Texcoord : TEXCOORD;
float3 NormalW : NORMAL;
float3 TangentW : TANGENT;
float4 InstanceTransform0 : INSTANCE_TRANSFORM0;
float4 InstanceTransform1 : INSTANCE_TRANSFORM1;
float4 InstanceTransform2 : INSTANCE_TRANSFORM2;
float4 InstanceLODParams : INSTANCE_LOD_PARAMS;
};

struct VS_OUTPUT
{
float3 TexcoordAndZ : Texcoord0;

float4 LODParams : LODParams;
float4 PositionH : SV_Position;
};

VS_OUTPUT RainShaftsVS( VS_INPUT Input )
{
VS_OUTPUT Output = (VS_OUTPUT)0;

//
Output.TexcoordAndZ.xy = Input.Texcoord;
Output.LODParams = Input.InstanceLODParams;

//
float3 meshScale = g_modelScale.xyz; // float3( 4, 4, 2 );
float3 meshBias = g_modelBias.xyz; // float3( -2, -2, -1 );
float3 PositionL = Input.PositionW * meshScale + meshBias;

// instanceWorld float4s:
float4x4 matInstanceWorld = float4x4(Input.InstanceTransform0, Input.InstanceTransform1,
Input.InstanceTransform2 , float4(0, 0, 0, 1) );

// (.z)
float4x4 matWorldInstanceLod = mul( g_rainShaftsViewProjMatrix, matInstanceWorld );
Output.TexcoordAndZ.z = mul( float4(PositionL, 1.0), transpose(matWorldInstanceLod) ).z;

// SV_Posiiton
float4x4 matModelViewProjection = mul(g_viewProjMatrix, matInstanceWorld );
Output.PositionH = mul( float4(PositionL, 1.0), transpose(matModelViewProjection) );

return Output;
}

मेरे shader की तुलना (बाएं) और मूल (दाएं):


मतभेद गणनाओं को प्रभावित नहीं करते हैं। मैंने अपने शेडर को फ्रेम में इंजेक्ट किया और सब कुछ अभी भी ठीक था!

पिक्सेल shader

अंत में!शुरू करने के लिए, मैं आपको इनपुट दिखाऊंगा:

दो बनावट का उपयोग यहां किया जाता है: शोर बनावट और गहराई बफर:



निरंतर बफ़र से मान:





और पिक्सेल shader के लिए कोडांतरक कोड:

ps_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb0[8], immediateIndexed
dcl_constantbuffer cb2[3], immediateIndexed
dcl_constantbuffer cb12[23], immediateIndexed
dcl_constantbuffer cb4[8], immediateIndexed
dcl_sampler s0, mode_default
dcl_sampler s15, mode_default
dcl_resource_texture2d (float,float,float,float) t0
dcl_resource_texture2d (float,float,float,float) t15
dcl_input_ps linear v0.xyz
dcl_input_ps linear v1.w
dcl_input_ps_siv v2.xy, position
dcl_output o0.xyzw
dcl_temps 1
0: mul r0.xy, cb0[0].xxxx, cb4[5].xyxx
1: mad r0.xy, v0.xyxx, cb4[4].xyxx, r0.xyxx
2: sample_indexable(texture2d)(float,float,float,float) r0.x, r0.xyxx, t0.xyzw, s0
3: add r0.y, -cb4[2].x, cb4[3].x
4: mad_sat r0.x, r0.x, r0.y, cb4[2].x
5: mul r0.x, r0.x, v0.y
6: mul r0.x, r0.x, v1.w
7: mul r0.x, r0.x, cb4[1].x
8: mul r0.yz, v2.xxyx, cb0[1].zzwz
9: sample_l(texture2d)(float,float,float,float) r0.y, r0.yzyy, t15.yxzw, s15, l(0)
10: mad r0.y, r0.y, cb12[22].x, cb12[22].y
11: mad r0.y, r0.y, cb12[21].x, cb12[21].y
12: max r0.y, r0.y, l(0.000100)
13: div r0.y, l(1.000000, 1.000000, 1.000000, 1.000000), r0.y
14: add r0.y, r0.y, -v0.z
15: mul_sat r0.y, r0.y, cb4[6].x
16: mul_sat r0.x, r0.y, r0.x
17: mad r0.y, cb0[7].y, r0.x, -r0.x
18: mad r0.x, cb4[7].x, r0.y, r0.x
19: mul r0.xyz, r0.xxxx, cb4[0].xyzx
20: log r0.xyz, r0.xyzx
21: mul r0.xyz, r0.xyzx, l(2.200000, 2.200000, 2.200000, 0.000000)
22: exp r0.xyz, r0.xyzx
23: mul r0.xyz, r0.xyzx, cb2[2].xyzx
24: mul o0.xyz, r0.xyzx, cb2[2].wwww
25: mov o0.w, l(0)
26: ret

वाह!काफी बड़ी मात्रा में, लेकिन वास्तव में, सब कुछ इतना बुरा नहीं है।

यहाँ क्या हो रहा है? सबसे पहले, हम cbuffer (cb0 [0] .x) और स्केल / ऑफसेट से बीता हुआ समय का उपयोग करके एनिमेटेड UVs की गणना करते हैं। इन टेक्सकोर्ड्स का उपयोग शोर बनावट (लाइन 2) से नमूना करने के लिए किया जाता है।

बनावट से शोर मूल्य प्राप्त करने के बाद, हम न्यूनतम / अधिकतम मूल्यों (आमतौर पर 0 और 1) के बीच अंतर करते हैं।

तब हम गुणा करते हैं, उदाहरण के लिए, बनावट V के समन्वय द्वारा (याद रखें कि समन्वय V 1 से 0 तक जाता है?) - पंक्ति 5.

इस प्रकार, हमने "चमक मुखौटा" की गणना की - यह इस तरह दिखता है:


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


गहराई परीक्षण

हम यह अनुकरण करना चाहते हैं कि बारिश का पर्दा दूर है (लेकिन जरूरी नहीं कि दूर के विमान पर)। ऐसा करने के लिए, हम एक और मुखौटा की गणना करते हैं, "दूर की वस्तुओं का मुखौटा।"

इसकी गणना निम्न सूत्र द्वारा की जाती है:

farObjectsMask = saturate( (FrustumDepth - CylinderWorldSpaceHeight) * 0.001 );

(0.001 को बफर से लिया गया है), जो हमें वांछित मास्क देता है:


(पैनापन प्रभाव के बारे में हिस्से में, मैंने पहले से ही सतही रूप से समझाया कि दृश्यता के पिरामिड की गहराई गहराई बफर से कैसे निकाली जाती है।)

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

जब दोनों मुखौटे को गुणा किया जाता है, तो अंतिम प्राप्त होता है:


इस अंतिम मास्क (लाइन 16) को प्राप्त करने के बाद, हम एक और प्रक्षेप करते हैं, जो लगभग कुछ भी नहीं (कम से कम परीक्षण किए गए मामले में) करता है, और फिर पर्दे (लाइन 19) के रंग से अंतिम मास्क को गुणा करें, गामा सुधार (लाइनें 20) करें -22) और अंतिम गुणन (23-24)।

अंत में, हम एक शून्य अल्फा मान के साथ एक रंग वापस करते हैं। ऐसा इसलिए है क्योंकि इस पास पर मिश्रण को सक्षम किया गया है:

FinalColor = SourceColor * 1.0 + (1.0 - SourceAlpha) * DestColor

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

SourceColor पिक्सेल shader से RGB आउटपुट है, और DestColor लक्ष्य को प्रस्तुत करने में पिक्सेल का वर्तमान RGB रंग है । चूंकि SourceAlpha हमेशा 0.0 के बराबर, उपरोक्त समीकरण को कम कर देता है: FinalColor = SourceColor + DestColor।

सीधे शब्दों में कहें, तो यहां हम योगात्मक मिश्रण का प्रदर्शन कर रहे हैं। यदि पिक्सेल शेडर वापस आता है (0, 0, 0), तो रंग समान रहेगा।

यहां समाप्त एचएलएसएल कोड है - मुझे लगता है कि समझाने के बाद यह समझना बहुत आसान होगा: मैं खुशी से कह सकता हूं कि मेरा पिक्सेल शेडर मूल के समान कोडांतरक कोड बनाता है। मुझे उम्मीद है कि आपको लेख पसंद आया होगा। पढ़ने के लिए धन्यवाद!

struct VS_OUTPUT
{
float3 TexcoordAndWorldspaceHeight : Texcoord0;
float4 LODParams : LODParams; // float4(1,1,1,1)
float4 PositionH : SV_Position;
};

float getFrustumDepth( in float depth )
{
// from [1-0] to [0-1]
float d = depth * cb12_v22.x + cb12_v22.y;

// special coefficents
d = d * cb12_v21.x + cb12_v21.y;

// return frustum depth
return 1.0 / max(d, 1e-4);
}

float4 EditedShaderPS( in VS_OUTPUT Input ) : SV_Target0
{
// * Input from Vertex Shader
float2 InputUV = Input.TexcoordAndWorldspaceHeight.xy;
float WorldHeight = Input.TexcoordAndWorldspaceHeight.z;
float LODParam = Input.LODParams.w;

// * Inputs
float elapsedTime = cb0_v0.x;
float2 uvAnimation = cb4_v5.xy;
float2 uvScale = cb4_v4.xy;
float minValue = cb4_v2.x; // 0.0
float maxValue = cb4_v3.x; // 1.0
float3 shaftsColor = cb4_v0.rgb; // RGB( 147, 162, 173 )

float3 finalColorFilter = cb2_v2.rgb; // float3( 1.175, 1.296, 1.342 );
float finalEffectIntensity = cb2_v2.w;

float2 invViewportSize = cb0_v1.zw;

float depthScale = cb4_v6.x; // 0.001

// sample noise
float2 uvOffsets = elapsedTime * uvAnimation;
float2 uv = InputUV * uvScale + uvOffsets;
float disturb = texture0.Sample( sampler0, uv ).x;

// * Intensity mask
float intensity = saturate( lerp(minValue, maxValue, disturb) );
intensity *= InputUV.y; // transition from (0, 1)
intensity *= LODParam; // usually 1.0
intensity *= cb4_v1.x; // 1.0

// Sample depth
float2 ScreenUV = Input.PositionH.xy * invViewportSize;
float hardwareDepth = texture15.SampleLevel( sampler15, ScreenUV, 0 ).x;
float frustumDepth = getFrustumDepth( hardwareDepth );


// * Calculate mask covering distant objects behind cylinder.

// Seems that the input really is world-space height (.z component, see vertex shader)
float depth = frustumDepth - WorldHeight;
float distantObjectsMask = saturate( depth * depthScale );

// * calculate final mask
float finalEffectMask = saturate( intensity * distantObjectsMask );

// cb0_v7.y and cb4_v7.x are set to 1.0 so I didn't bother with naming them :)
float paramX = finalEffectMask;
float paramY = cb0_v7.y * finalEffectMask;
float effectAmount = lerp(paramX, paramY, cb4_v7.x);

// color of shafts comes from contant buffer
float3 effectColor = effectAmount * shaftsColor;

// gamma correction
effectColor = pow(effectColor, 2.2);

// final multiplications
effectColor *= finalColorFilter;
effectColor *= finalEffectIntensity;

// return with zero alpha 'cause the blending used here is:
// SourceColor * 1.0 + (1.0 - SrcAlpha) * DestColor
return float4( effectColor, 0.0 );
}