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

हाल ही में, मैंने द विचर 3 के प्रतिपादन से निपटना शुरू किया। इस गेम में अद्भुत रेंडरिंग तकनीक है। इसके अलावा, वह कथानक / संगीत / गेमप्ले के मामले में शानदार है।



इस लेख में मैं The Witcher 3 को प्रस्तुत करने के लिए उपयोग किए जाने वाले समाधानों के बारे में बात करूंगा। यह Adrian Correger द्वारा GTA V ग्राफिक्स के विश्लेषण के रूप में व्यापक नहीं होगा, कम से कम अभी के लिए।

हम टोन सुधार के रिवर्स इंजीनियरिंग के साथ शुरू करेंगे।

भाग 1: टोन सुधार

अधिकांश आधुनिक एएए गेम्स में, रेंडरिंग चरणों में से एक आवश्यक रूप से टोन सुधार है।

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

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

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

हम रेंडरडॉक में नोविग्राड के मुख्य quests में से एक के इस फ्रेम पर कब्जा करने के साथ काम करेंगे। सभी सेटिंग्स अधिकतम हैं:


थोड़ा खोज करने के बाद, मुझे टोन सुधार के लिए एक आह्वान मिला! जैसा कि मैंने ऊपर उल्लेख किया है, एचडीआर रंगों (बनावट संख्या 0, पूर्ण रिज़ॉल्यूशन) और दृश्य की औसत चमक (बनावट संख्या 1, 1x1, फ़्लोटिंग पॉइंट, पहले गणना किए गए कंपाउंडर द्वारा गणना) का एक बफर है।


आइए पिक्सेल shader के लिए कोडांतरक कोड पर एक नज़र डालें:

ps_5_0 dcl_globalFlags refactoringAllowed dcl_constantbuffer cb3[17], immediateIndexed 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 4 0: ld_indexable(texture2d)(float,float,float,float) r0.x, l(0, 0, 0, 0), t1.xyzw 1: max r0.x, r0.x, cb3[4].y 2: min r0.x, r0.x, cb3[4].z 3: max r0.x, r0.x, l(0.000100) 4: mul r0.y, cb3[16].x, l(11.200000) 5: div r0.x, r0.x, r0.y 6: log r0.x, r0.x 7: mul r0.x, r0.x, cb3[16].z 8: exp r0.x, r0.x 9: mul r0.x, r0.y, r0.x 10: div r0.x, cb3[16].x, r0.x 11: ftou r1.xy, v0.xyxx 12: mov r1.zw, l(0, 0, 0, 0) 13: ld_indexable(texture2d)(float,float,float,float) r0.yzw, r1.xyzw, t0.wxyz 14: mul r0.xyz, r0.yzwy, r0.xxxx 15: mad r1.xyz, cb3[7].xxxx, r0.xyzx, cb3[7].yyyy 16: mul r2.xy, cb3[8].yzyy, cb3[8].xxxx 17: mad r1.xyz, r0.xyzx, r1.xyzx, r2.yyyy 18: mul r0.w, cb3[7].y, cb3[7].z 19: mad r3.xyz, cb3[7].xxxx, r0.xyzx, r0.wwww 20: mad r0.xyz, r0.xyzx, r3.xyzx, r2.xxxx 21: div r0.xyz, r0.xyzx, r1.xyzx 22: mad r0.w, cb3[7].x, l(11.200000), r0.w 23: mad r0.w, r0.w, l(11.200000), r2.x 24: div r1.x, cb3[8].y, cb3[8].z 25: add r0.xyz, r0.xyzx, -r1.xxxx 26: max r0.xyz, r0.xyzx, l(0, 0, 0, 0) 27: mul r0.xyz, r0.xyzx, cb3[16].yyyy 28: mad r1.y, cb3[7].x, l(11.200000), cb3[7].y 29: mad r1.y, r1.y, l(11.200000), r2.y 30: div r0.w, r0.w, r1.y 31: add r0.w, -r1.x, r0.w 32: max r0.w, r0.w, l(0) 33: div o0.xyz, r0.xyzx, r0.wwww 34: mov o0.w, l(1.000000) 35: ret 

ध्यान देने योग्य कई बिंदु हैं। सबसे पहले, लोड की गई चमक का उपयोग करने के बराबर नहीं है, क्योंकि यह कलाकारों द्वारा चुने गए मूल्यों (निरंतर बफर से) के भीतर सीमित (अधिकतम / मिनट कॉल) है। यह सुविधाजनक है क्योंकि यह आपको दृश्य की उच्च या निम्न शटर गति से बचने की अनुमति देता है। यह कदम बहुत आम लगता है, लेकिन मैंने इसे पहले कभी नहीं किया है। दूसरे, कोई व्यक्ति जो टोन करेक्शन कर्व्स से परिचित है, वह तुरंत इस "11.2" मान को पहचान लेगा, क्योंकि वास्तव में यह जॉन हबल के अनचार्टेड 2 टोन करेक्शन वक्र से सफेद बिंदु का मान है।

वायु सेना के मापदंडों को cbuffer से लोड किया जाता है।

तो, हमारे पास तीन और पैरामीटर हैं: cb3_v16.x, cb3_v16.y, cb3_v16.z। हम उनके अर्थ की जांच कर सकते हैं:


मेरा कूबड़:

मेरा मानना ​​है कि "x" एक प्रकार का "सफेद स्केल" या मध्यम ग्रे है, क्योंकि यह 11.2 (पंक्ति 4) से गुणा किया जाता है, और उसके बाद शटर गति सेटिंग (लाइन 10) की गणना में एक अंश के रूप में उपयोग किया जाता है।

"Y" - मैंने इसे "u2 अंश कारक" कहा, और जल्द ही आप देखेंगे कि क्यों।

"Z" "घातांक पैरामीटर" है, क्योंकि इसका उपयोग ट्रिपल लॉग / mul / exp (वास्तव में, घातांक में) किया जाता है।

लेकिन संदेह के एक डिग्री के साथ इन चर नामों का इलाज करें!

भी:

cb3_v4.yz - स्वीकार्य चमक की न्यूनतम / अधिकतम मान,
cb3_v7.xyz - Uncharted2 वक्र के एसी पैरामीटर,
cb3_v8.xyz - Uncharted2 वक्र के DF पैरामीटर।

अब चलिए मुश्किल हिस्से पर आते हैं - हम एक एचएलएसएल शेडर लिखेंगे जो हमें बिल्कुल समान कोडर देगा।

यह बहुत कठिन हो सकता है, और जितना लंबा शेडर होगा, कार्य उतना ही कठिन होगा। सौभाग्य से, कुछ समय पहले मैंने hlsl-> asm ब्राउज़ करने के लिए एक उपकरण लिखा था।

देवियों और सज्जनों ... स्वागत है आपका स्वागत है डी 3 डी एसडरडिसबसेम्बलर!


कोड के साथ प्रयोग करने के बाद, मुझे तैयार एचएलएसएल टोनल करेक्शन द विचर 3 मिला :

  cbuffer cBuffer : register (b3) { float4 cb3_v0; float4 cb3_v1; float4 cb3_v2; float4 cb3_v3; float4 cb3_v4; float4 cb3_v5; float4 cb3_v6; float4 cb3_v7; float4 cb3_v8; float4 cb3_v9; float4 cb3_v10; float4 cb3_v11; float4 cb3_v12; float4 cb3_v13; float4 cb3_v14; float4 cb3_v15; float4 cb3_v16, cb3_v17; } Texture2D TexHDRColor : register (t0); Texture2D TexAvgLuminance : register (t1); struct VS_OUTPUT_POSTFX { float4 Position : SV_Position; }; float3 U2Func( float A, float B, float C, float D, float E, float F, float3 x ) { return ((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F)) - E/F; } float3 ToneMapU2Func( float A, float B, float C, float D, float E, float F, float3 color, float numMultiplier ) { float3 numerator = U2Func( A, B, C, D, E, F, color ); numerator = max( numerator, 0 ); numerator.rgb *= numMultiplier; float3 denominator = U2Func( A, B, C, D, E, F, 11.2 ); denominator = max( denominator, 0 ); return numerator / denominator; } float4 ToneMappingPS( VS_OUTPUT_POSTFX Input) : SV_Target0 { float avgLuminance = TexAvgLuminance.Load( int3(0, 0, 0) ); avgLuminance = clamp( avgLuminance, cb3_v4.y, cb3_v4.z ); avgLuminance = max( avgLuminance, 1e-4 ); float scaledWhitePoint = cb3_v16.x * 11.2; float luma = avgLuminance / scaledWhitePoint; luma = pow( luma, cb3_v16.z ); luma = luma * scaledWhitePoint; luma = cb3_v16.x / luma; float3 HDRColor = TexHDRColor.Load( uint3(Input.Position.xy, 0) ).rgb; float3 color = ToneMapU2Func( cb3_v7.x, cb3_v7.y, cb3_v7.z, cb3_v8.x, cb3_v8.y, cb3_v8.z, luma*HDRColor, cb3_v16.y); return float4(color, 1); } 

इसकी पुष्टि करने के लिए मेरी उपयोगिता का स्क्रीनशॉट:


देखा!

मेरा मानना ​​है कि यह TW3 टोन सुधार का काफी सटीक कार्यान्वयन है, कम से कम कोडांतरक कोड के संदर्भ में। मैंने इसे पहले ही अपने ढांचे में लागू कर दिया है और यह बहुत अच्छा है!

मैंने कहा "पर्याप्त" क्योंकि मुझे नहीं पता है कि ToneMapU2Func में हर क्यों शून्य पर अधिकतम हो जाता है। 0 से विभाजित करते समय, आपको अपरिभाषित होना चाहिए?

यह समाप्त हो सकता है, लेकिन लगभग दुर्घटना से मुझे इस फ्रेम में TW3 टोन शेडर का एक और संस्करण मिला, जिसका उपयोग सुंदर सूर्यास्त के लिए किया जाता है (यह दिलचस्प है कि इसका उपयोग न्यूनतम ग्राफिक्स सेटिंग्स के साथ किया जाता है!)


आइए इसे देखें। सबसे पहले, shader के लिए कोडांतरक कोड:

  ps_5_0 dcl_globalFlags refactoringAllowed dcl_constantbuffer cb3[18], immediateIndexed 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 5 0: ld_indexable(texture2d)(float,float,float,float) r0.x, l(0, 0, 0, 0), t1.xyzw 1: max r0.y, r0.x, cb3[9].y 2: max r0.x, r0.x, cb3[4].y 3: min r0.x, r0.x, cb3[4].z 4: min r0.y, r0.y, cb3[9].z 5: max r0.xy, r0.xyxx, l(0.000100, 0.000100, 0.000000, 0.000000) 6: mul r0.z, cb3[17].x, l(11.200000) 7: div r0.y, r0.y, r0.z 8: log r0.y, r0.y 9: mul r0.y, r0.y, cb3[17].z 10: exp r0.y, r0.y 11: mul r0.y, r0.z, r0.y 12: div r0.y, cb3[17].x, r0.y 13: ftou r1.xy, v0.xyxx 14: mov r1.zw, l(0, 0, 0, 0) 15: ld_indexable(texture2d)(float,float,float,float) r1.xyz, r1.xyzw, t0.xyzw 16: mul r0.yzw, r0.yyyy, r1.xxyz 17: mad r2.xyz, cb3[11].xxxx, r0.yzwy, cb3[11].yyyy 18: mul r3.xy, cb3[12].yzyy, cb3[12].xxxx 19: mad r2.xyz, r0.yzwy, r2.xyzx, r3.yyyy 20: mul r1.w, cb3[11].y, cb3[11].z 21: mad r4.xyz, cb3[11].xxxx, r0.yzwy, r1.wwww 22: mad r0.yzw, r0.yyzw, r4.xxyz, r3.xxxx 23: div r0.yzw, r0.yyzw, r2.xxyz 24: mad r1.w, cb3[11].x, l(11.200000), r1.w 25: mad r1.w, r1.w, l(11.200000), r3.x 26: div r2.x, cb3[12].y, cb3[12].z 27: add r0.yzw, r0.yyzw, -r2.xxxx 28: max r0.yzw, r0.yyzw, l(0, 0, 0, 0) 29: mul r0.yzw, r0.yyzw, cb3[17].yyyy 30: mad r2.y, cb3[11].x, l(11.200000), cb3[11].y 31: mad r2.y, r2.y, l(11.200000), r3.y 32: div r1.w, r1.w, r2.y 33: add r1.w, -r2.x, r1.w 34: max r1.w, r1.w, l(0) 35: div r0.yzw, r0.yyzw, r1.wwww 36: mul r1.w, cb3[16].x, l(11.200000) 37: div r0.x, r0.x, r1.w 38: log r0.x, r0.x 39: mul r0.x, r0.x, cb3[16].z 40: exp r0.x, r0.x 41: mul r0.x, r1.w, r0.x 42: div r0.x, cb3[16].x, r0.x 43: mul r1.xyz, r1.xyzx, r0.xxxx 44: mad r2.xyz, cb3[7].xxxx, r1.xyzx, cb3[7].yyyy 45: mul r3.xy, cb3[8].yzyy, cb3[8].xxxx 46: mad r2.xyz, r1.xyzx, r2.xyzx, r3.yyyy 47: mul r0.x, cb3[7].y, cb3[7].z 48: mad r4.xyz, cb3[7].xxxx, r1.xyzx, r0.xxxx 49: mad r1.xyz, r1.xyzx, r4.xyzx, r3.xxxx 50: div r1.xyz, r1.xyzx, r2.xyzx 51: mad r0.x, cb3[7].x, l(11.200000), r0.x 52: mad r0.x, r0.x, l(11.200000), r3.x 53: div r1.w, cb3[8].y, cb3[8].z 54: add r1.xyz, -r1.wwww, r1.xyzx 55: max r1.xyz, r1.xyzx, l(0, 0, 0, 0) 56: mul r1.xyz, r1.xyzx, cb3[16].yyyy 57: mad r2.x, cb3[7].x, l(11.200000), cb3[7].y 58: mad r2.x, r2.x, l(11.200000), r3.y 59: div r0.x, r0.x, r2.x 60: add r0.x, -r1.w, r0.x 61: max r0.x, r0.x, l(0) 62: div r1.xyz, r1.xyzx, r0.xxxx 63: add r0.xyz, r0.yzwy, -r1.xyzx 64: mad o0.xyz, cb3[13].xxxx, r0.xyzx, r1.xyzx 65: mov o0.w, l(1.000000) 66: ret 

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

और एचएलएसएल:

  cbuffer cBuffer : register (b3) { float4 cb3_v0; float4 cb3_v1; float4 cb3_v2; float4 cb3_v3; float4 cb3_v4; float4 cb3_v5; float4 cb3_v6; float4 cb3_v7; float4 cb3_v8; float4 cb3_v9; float4 cb3_v10; float4 cb3_v11; float4 cb3_v12; float4 cb3_v13; float4 cb3_v14; float4 cb3_v15; float4 cb3_v16, cb3_v17; } Texture2D TexHDRColor : register (t0); Texture2D TexAvgLuminance : register (t1); float3 U2Func( float A, float B, float C, float D, float E, float F, float3 x ) { return ((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F)) - E/F; } float3 ToneMapU2Func( float A, float B, float C, float D, float E, float F, float3 color, float numMultiplier ) { float3 numerator = U2Func( A, B, C, D, E, F, color ); numerator = max( numerator, 0 ); numerator.rgb *= numMultiplier; float3 denominator = U2Func( A, B, C, D, E, F, 11.2 ); denominator = max( denominator, 0 ); return numerator / denominator; } struct VS_OUTPUT_POSTFX { float4 Position : SV_Position; }; float getExposure(float avgLuminance, float minLuminance, float maxLuminance, float middleGray, float powParam) { avgLuminance = clamp( avgLuminance, minLuminance, maxLuminance ); avgLuminance = max( avgLuminance, 1e-4 ); float scaledWhitePoint = middleGray * 11.2; float luma = avgLuminance / scaledWhitePoint; luma = pow( luma, powParam); luma = luma * scaledWhitePoint; float exposure = middleGray / luma; return exposure; } float4 ToneMappingPS( VS_OUTPUT_POSTFX Input) : SV_Target0 { float avgLuminance = TexAvgLuminance.Load( int3(0, 0, 0) ); float exposure1 = getExposure( avgLuminance, cb3_v9.y, cb3_v9.z, cb3_v17.x, cb3_v17.z); float exposure2 = getExposure( avgLuminance, cb3_v4.y, cb3_v4.z, cb3_v16.x, cb3_v16.z); float3 HDRColor = TexHDRColor.Load( uint3(Input.Position.xy, 0) ).rgb; float3 color1 = ToneMapU2Func( cb3_v11.x, cb3_v11.y, cb3_v11.z, cb3_v12.x, cb3_v12.y, cb3_v12.z, exposure1*HDRColor, cb3_v17.y); float3 color2 = ToneMapU2Func( cb3_v7.x, cb3_v7.y, cb3_v7.z, cb3_v8.x, cb3_v8.y, cb3_v8.z, exposure2*HDRColor, cb3_v16.y); float3 finalColor = lerp( color2, color1, cb3_v13.x ); return float4(finalColor, 1); } 

यही है, वास्तव में, हमारे पास नियंत्रण मापदंडों के दो सेट हैं, हम टोन सुधार के साथ दो रंगों की गणना करते हैं, और अंत में हम उन्हें प्रक्षेपित करते हैं। स्मार्ट निर्णय!

भाग 2: आँख अनुकूलन

दूसरा भाग ज्यादा सरल होगा।

पहले भाग में, मैंने दिखाया कि TW3 में तानवाला सुधार कैसे किया जाता है। सैद्धांतिक पृष्ठभूमि की व्याख्या करते हुए, मैंने संक्षेप में आंख के अनुकूलन का उल्लेख किया। और आपको पता है क्या? इस भाग में मैं बात करूंगा कि आंख के इस अनुकूलन को कैसे महसूस किया जाता है।

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

अंधेरे में, हमारे विद्यार्थियों को पतला किया जाता है ताकि अधिक प्रकाश उनके माध्यम से रेटिना में प्रवेश करे। जब यह हल्का हो जाता है, तो हमारे शिष्य कम हो जाते हैं और कभी-कभी हम अपनी आँखें बंद कर लेते हैं क्योंकि यह "दर्द" होता है।

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

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

चलो शुरू हो जाओ! संगति के लिए, हम नोविग्राद से एक ही फ्रेम का विश्लेषण करेंगे।


अब हम फ्रेम कैप्चर प्रोग्राम RenderDoc में गहराई से जाएंगे। आंख का अनुकूलन आमतौर पर तानवाला सुधार से ठीक पहले किया जाता है, और द विचर 3 कोई अपवाद नहीं है।


आइए पिक्सेल शैडर की स्थिति को देखें:


हमारे पास दो इनपुट स्रोत हैं - 2 बनावट, R32_FLOAT, 1x1 (एक पिक्सेल)। बनावट 0 में पिछले फ्रेम से दृश्य की औसत चमक होती है। बनावट 1 में वर्तमान फ्रेम से दृश्य की औसत चमक शामिल है (गणना इस कंपकंपी से ठीक पहले - मैंने इसे नीले रंग में चिह्नित किया है)।

यह अपेक्षित है कि एक आउटपुट है - R32_FLOAT, 1x1। चलो पिक्सेल shader को देखें।

  ps_5_0 dcl_globalFlags refactoringAllowed dcl_constantbuffer cb3[1], immediateIndexed dcl_sampler s0, mode_default dcl_sampler s1, mode_default dcl_resource_texture2d (float,float,float,float) t0 dcl_resource_texture2d (float,float,float,float) t1 dcl_output o0.xyzw dcl_temps 1 0: sample_l(texture2d)(float,float,float,float) r0.x, l(0, 0, 0, 0), t1.xyzw, s1, l(0) 1: sample_l(texture2d)(float,float,float,float) r0.y, l(0, 0, 0, 0), t0.yxzw, s0, l(0) 2: ge r0.z, r0.y, r0.x 3: add r0.x, -r0.y, r0.x 4: movc r0.z, r0.z, cb3[0].x, cb3[0].y 5: mad o0.xyzw, r0.zzzz, r0.xxxx, r0.yyyy 6: ret 

वाह, कितना सरल है! कोडांतरक कोड की केवल 7 लाइनें। यहाँ क्या हो रहा है? मैं प्रत्येक पंक्ति की व्याख्या करूंगा:

0) वर्तमान फ्रेम की औसत चमक प्राप्त करें।
1) पिछले फ्रेम की औसत चमक प्राप्त करें।
2) एक जांच करें: क्या वर्तमान चमक पिछले फ्रेम की चमक से कम या बराबर है?
यदि हाँ, तो चमक कम हो जाती है, यदि नहीं, तो चमक बढ़ जाती है।
3) अंतर की गणना करें: अंतर = currentLum - पूर्ववर्ती।
4) यह सशर्त स्थानांतरण (movc) निरंतर बफर से गति कारक प्रदान करता है। चेक के परिणाम के आधार पर, लाइन 2 से दो अलग-अलग मान निर्दिष्ट किए जा सकते हैं। यह एक स्मार्ट चाल है, क्योंकि इस तरह आप कम चमक और बढ़ती चमक दोनों के लिए अलग-अलग अनुकूलन गति प्राप्त कर सकते हैं। लेकिन अध्ययन किए गए फ्रेम में, दोनों मूल्य समान हैं और 0.11 से 0.3 तक भिन्न हैं।
5) अनुकूलित चमक की अंतिम गणना: रूपांतरित- गति = गति-संवाहक * अंतर + पूर्ववर्ती।
6) shader का अंत

यह एचएलएसएल में काफी सरलता से लागू किया गया है:

  // The Witcher 3 eye adaptation shader cbuffer cBuffer : register (b3) { float4 cb3_v0; } struct VS_OUTPUT_POSTFX { float4 Position : SV_Position; }; SamplerState samplerPointClamp : register (s0); SamplerState samplerPointClamp2 : register (s1); Texture2D TexPreviousAvgLuminance : register (t0); Texture2D TexCurrentAvgLuminance : register (t1); float4 TW3_EyeAdaptationPS(VS_OUTPUT_POSTFX Input) : SV_TARGET { // Get current and previous luminance. float currentAvgLuminance = TexCurrentAvgLuminance.SampleLevel( samplerPointClamp2, float2(0.0, 0.0), 0 ); float previousAvgLuminance = TexPreviousAvgLuminance.SampleLevel( samplerPointClamp, float2(0.0, 0.0), 0 ); // Difference between current and previous luminance. float difference = currentAvgLuminance - previousAvgLuminance; // Scale factor. Can be different for both falling down and rising up of luminance. // It affects speed of adaptation. // Small conditional test is performed here, so different speed can be set differently for both these cases. float adaptationSpeedFactor = (currentAvgLuminance <= previousAvgLuminance) ? cb3_v0.x : cb3_v0.y; // Calculate adapted luminance. float adaptedLuminance = adaptationSpeedFactor * difference + previousAvgLuminance; return adaptedLuminance; } 

ये लाइनें हमें समान कोडांतरक कोड देती हैं। मैं केवल फ्लोट 4 के साथ आउटपुट के प्रकार को फ्लोट के साथ बदलने का सुझाव दूंगा । बैंडविड्थ की बर्बादी की कोई जरूरत नहीं है। यह है कि कैसे Witcher 3 आंख अनुकूलन लागू करता है। बहुत आसान है, है ना?

पुनश्च। बाल्डर कार्लसन (ट्विटर: @baldurk ) को रेंडरडोक के लिए बहुत धन्यवाद। कार्यक्रम बहुत अच्छा है।

भाग 3: रंगीन विपथन

क्रोमियम अपघटन एक प्रभाव है जो मुख्यतः सस्ते लेंस में पाया जाता है। ऐसा इसलिए होता है क्योंकि लेंस में दृश्य प्रकाश की विभिन्न लंबाई के लिए अलग-अलग अपवर्तक सूचक होते हैं। इसके परिणामस्वरूप, एक दृश्य विकृति दिखाई देती है। हालांकि, हर कोई इसे पसंद नहीं करता है। सौभाग्य से, चुड़ैल 3 में यह प्रभाव बहुत सूक्ष्म है, और इसलिए गेमप्ले (मुझे, कम से कम) में परेशान नहीं करना है। लेकिन आप चाहें तो इसे बंद कर सकते हैं।

आइए एक दृश्य के उदाहरण पर एक नज़र डालें जिसमें रंगीन विपथन है और इसके बिना:


रंगीन विपथन शामिल है


क्रोमेटिक अपघटन अक्षम

क्या आपको किनारों के पास कोई अंतर दिखाई देता है? मुझे न तो। चलिए एक और सीन आजमाते हैं:


रंगीन विपथन शामिल है। संकेतित क्षेत्र में मामूली "लाल" विरूपण की सूचना दें।

हाँ, बहुत बेहतर! यहां अंधेरे और हल्के क्षेत्रों के बीच का अंतर अधिक मजबूत है, और कोने में हमें थोड़ी विकृति दिखाई देती है। जैसा कि आप देख सकते हैं, यह प्रभाव बहुत कमजोर है। हालांकि, मैं सोच रहा था कि इसे कैसे लागू किया जाता है। सबसे जिज्ञासु भाग पर चलते हैं: कोड!

कार्यान्वयन

पहली बात यह है कि पिक्सेल shader के साथ सही ड्रॉ कॉल लगता है। वास्तव में, रंगीन विपथन बड़े "पोस्ट-प्रोसेसिंग" पिक्सेल शेडर का हिस्सा है, जिसमें क्रोमैटिक एब्रेशन, विग्निटिंग और गामा सुधार शामिल हैं। यह सब एक एकल पिक्सेल shader के अंदर है। चलो पिक्सेल shader के लिए कोडांतरक कोड पर करीब से नज़र डालते हैं:

  ps_5_0 dcl_globalFlags refactoringAllowed dcl_constantbuffer cb3[18], immediateIndexed dcl_sampler s1, mode_default dcl_resource_texture2d (float,float,float,float) t0 dcl_input_ps_siv v0.xy, position dcl_input_ps linear v1.zw dcl_output o0.xyzw dcl_temps 4 0: mul r0.xy, v0.xyxx, cb3[17].zwzz 1: mad r0.zw, v0.xxxy, cb3[17].zzzw, -cb3[17].xxxy 2: div r0.zw, r0.zzzw, cb3[17].xxxy 3: dp2 r1.x, r0.zwzz, r0.zwzz 4: sqrt r1.x, r1.x 5: add r1.y, r1.x, -cb3[16].y 6: mul_sat r1.y, r1.y, cb3[16].z 7: sample_l(texture2d)(float,float,float,float) r2.xyz, r0.xyxx, t0.xyzw, s1, l(0) 8: lt r1.z, l(0), r1.y 9: if_nz r1.z 10: mul r1.y, r1.y, r1.y 11: mul r1.y, r1.y, cb3[16].x 12: max r1.x, r1.x, l(0.000100) 13: div r1.x, r1.y, r1.x 14: mul r0.zw, r0.zzzw, r1.xxxx 15: mul r0.zw, r0.zzzw, cb3[17].zzzw 16: mad r0.xy, -r0.zwzz, l(2.000000, 2.000000, 0.000000, 0.000000), r0.xyxx 17: sample_l(texture2d)(float,float,float,float) r2.x, r0.xyxx, t0.xyzw, s1, l(0) 18: mad r0.xy, v0.xyxx, cb3[17].zwzz, -r0.zwzz 19: sample_l(texture2d)(float,float,float,float) r2.y, r0.xyxx, t0.xyzw, s1, l(0) 20: endif ... 

और कफ़न मूल्यों के लिए:


तो, आइए समझने की कोशिश करें कि यहां क्या हो रहा है। वास्तव में, cb3_v17.xy गुणात्मक विपथन का केंद्र है, इसलिए पहली पंक्तियाँ टेक्सल निर्देशांक से 2d वेक्टर की गणना करती हैं (cb3_v17.zw = व्यूपोर्ट साइज़ का पारस्परिक) "वर्णिक विपथन के केंद्र" और इसकी लंबाई, फिर अन्य गणना, सत्यापन और ब्रांचिंग करते हैं। । रंगीन विपथन को लागू करते समय, हम निरंतर बफर से कुछ मूल्यों का उपयोग करके विस्थापन की गणना करते हैं और चैनलों को आर और जी को विकृत करते हैं। सामान्य तौर पर, स्क्रीन के किनारों के करीब, प्रभाव जितना मजबूत होता है। लाइन 10 बहुत दिलचस्प है क्योंकि यह पिक्सल को "करीब" ले जाता है, खासकर जब हम विपथन को अतिरंजित करते हैं। मैं अपने प्रभाव का अहसास आपके साथ सहर्ष साझा करूंगा। हमेशा की तरह, संशयवाद के एक (ठोस) हिस्से के साथ चर नाम लें। और ध्यान दें कि प्रभाव गामा सुधार से पहले लागू किया जाता है।

  void ChromaticAberration( float2 uv, inout float3 color ) { // User-defined params float2 chromaticAberrationCenter = float2(0.5, 0.5); float chromaticAberrationCenterAvoidanceDistance = 0.2; float fA = 1.25; float fChromaticAbberationIntensity = 30; float fChromaticAberrationDistortionSize = 0.75; // Calculate vector float2 chromaticAberrationOffset = uv - chromaticAberrationCenter; chromaticAberrationOffset = chromaticAberrationOffset / chromaticAberrationCenter; float chromaticAberrationOffsetLength = length(chromaticAberrationOffset); // To avoid applying chromatic aberration in center, subtract small value from // just calculated length. float chromaticAberrationOffsetLengthFixed = chromaticAberrationOffsetLength - chromaticAberrationCenterAvoidanceDistance; float chromaticAberrationTexel = saturate(chromaticAberrationOffsetLengthFixed * fA); float fApplyChromaticAberration = (0.0 < chromaticAberrationTexel); if (fApplyChromaticAberration) { chromaticAberrationTexel *= chromaticAberrationTexel; chromaticAberrationTexel *= fChromaticAberrationDistortionSize; chromaticAberrationOffsetLength = max(chromaticAberrationOffsetLength, 1e-4); float fMultiplier = chromaticAberrationTexel / chromaticAberrationOffsetLength; chromaticAberrationOffset *= fMultiplier; chromaticAberrationOffset *= g_Viewport.zw; chromaticAberrationOffset *= fChromaticAbberationIntensity; float2 offsetUV = -chromaticAberrationOffset * 2 + uv; color.r = TexColorBuffer.SampleLevel(samplerLinearClamp, offsetUV, 0).r; offsetUV = uv - chromaticAberrationOffset; color.g = TexColorBuffer.SampleLevel(samplerLinearClamp, offsetUV, 0).g; } } 

मैंने ऑफसेट के आकार को बढ़ाने के लिए "fChromaticAberrationIntensity" को जोड़ा, और इसलिए प्रभाव की ताकत, जैसा कि नाम से पता चलता है (TW3 = 1.0)। तीव्रता = 40:


वह सब है! आशा है आपको यह हिस्सा अच्छा लगा होगा

भाग 4: विगनेटिंग

Vignetting खेलों में उपयोग किए जाने वाले सबसे आम पोस्ट-प्रोसेसिंग प्रभावों में से एक है। वह फोटोग्राफी में भी लोकप्रिय हैं। थोड़ा छायांकित कोने एक सुंदर प्रभाव पैदा कर सकते हैं। कई प्रकार के विग्नेटिंग हैं। उदाहरण के लिए, अवास्तविक इंजन 4 प्राकृतिक का उपयोग करता है। लेकिन द विचर पर वापस 3. विग्नेटिंग के साथ और बिना फ्रेम के इंटरेक्टिव तुलना देखने के लिए यहां क्लिक करें । तुलना को Witcher 3 के लिए NVIDIA प्रदर्शन गाइड से लिया गया है ।


विगनेटिंग के साथ "द विचर 3" का स्क्रीनशॉट चालू हुआ।

ध्यान दें कि ऊपरी बाएं कोने (आकाश) को छवि के अन्य भागों की तरह छायांकित नहीं किया गया है। बाद में हम इस पर लौट आएंगे।

कार्यान्वयन का विवरण

सबसे पहले, द विचर 3 के मूल संस्करण (जो 19 मई, 2015 को जारी किया गया था) और द विचर 3: ब्लड एंड वाइन में इस्तेमाल होने वाले विगनेटिंग के बीच थोड़ा अंतर है। पूर्व में, "उलटा ढाल" की गणना पिक्सेल शेडर के अंदर की जाती है, और बाद में, यह 256x256 2D बनावट में पहले से गणना की जाती है:


बनावट 256x256, "रक्त और शराब के पूरक" में "रिवर्स ग्रेडिएंट" के रूप में उपयोग किया जाता है।

मैं "ब्लड एंड वाइन" (जिस तरह से, एक महान खेल) से shader का उपयोग करूंगा। अधिकांश अन्य खेलों की तरह, डायन 3 विग्निटिंग की गणना अंतिम पोस्ट-प्रोसेसिंग के पिक्सेल शेडर में की जाती है। कोडांतरक कोड पर एक नज़र डालें:

  ... 44: log r0.xyz, r0.xyzx 45: mul r0.xyz, r0.xyzx, l(0.454545, 0.454545, 0.454545, 0.000000) 46: exp r0.xyz, r0.xyzx 47: mul r1.xyz, r0.xyzx, cb3[9].xyzx 48: sample_indexable(texture2d)(float,float,float,float) r0.w, v1.zwzz, t2.yzwx, s2 49: log r2.xyz, r1.xyzx 50: mul r2.xyz, r2.xyzx, l(2.200000, 2.200000, 2.200000, 0.000000) 51: exp r2.xyz, r2.xyzx 52: dp3 r1.w, r2.xyzx, cb3[6].xyzx 53: add_sat r1.w, -r1.w, l(1.000000) 54: mul r1.w, r1.w, cb3[6].w 55: mul_sat r0.w, r0.w, r1.w 56: mad r0.xyz, -r0.xyzx, cb3[9].xyzx, cb3[7].xyzx 57: mad r0.xyz, r0.wwww, r0.xyzx, r1.xyzx ... 

दिलचस्प! ऐसा प्रतीत होता है कि गामा (लाइन 46) और रैखिक रिक्त स्थान (लाइन 51) दोनों का उपयोग विगनेटिंग की गणना के लिए किया जाता है। 48 रेखा पर, हम "उलटा ढाल" की बनावट का नमूना लेते हैं। cb3 [9] .xyz विग्नटिंग से संबंधित नहीं है। जाँच किए गए प्रत्येक फ्रेम में, इसे फ़्लोट 3 (1.0, 1.0, 1.0) मान दिया गया है, अर्थात, यह संभवतः फ़ेड-इन / फेड-आउट प्रभावों में उपयोग किया जाने वाला अंतिम फ़िल्टर है। TW3 में विगनेटिंग के लिए तीन मुख्य पैरामीटर हैं:

• अपारदर्शिता (cb3 [6] .w) - विगनेटिंग की ताकत को प्रभावित करता है। 0 - कोई विग्निटिंग नहीं, 1 - अधिकतम विग्निटिंग। मेरे अवलोकनों के अनुसार, बेस द विचर 3 में यह लगभग 1.0 है, जबकि रक्त और शराब में यह लगभग 0.15 है।
• रंग (cb3 [7] .xyz) - TW3 विगनेटिंग की एक उत्कृष्ट विशेषता इसका रंग बदलने की क्षमता है। यह काला होना जरूरी नहीं है, लेकिन व्यवहार में ... आमतौर पर इसमें फ्लोट 3 (3.0 / 255.0, 4.0 / 255.0, 5.0 / 255.0) और इसी तरह के मूल्य होते हैं - सामान्य मामले में, ये 0.00392156 के गुणक होते हैं - 1.0 या 255.0
• वेट (cb3 [6] .xyz) एक बहुत ही दिलचस्प पैरामीटर है। मैंने हमेशा "फ्लैट" विगनेट्स देखे, उदाहरण के लिए:

विशिष्ट विगनेटिंग मास्क

लेकिन वजन (लाइन 52) का उपयोग करके, आप बहुत दिलचस्प परिणाम प्राप्त कर सकते हैं:


भार का उपयोग करते हुए TW3 विगनेटिंग मास्क की गणना की गई

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


कोड

यहां एचएलएसएल पर TW3 विगनेटिंग का मेरा कार्यान्वयन है।

गामाटॉइलियर = पाव (रंग, 2.2)

  /* // The Witcher 3 vignette. // // Input color is in gamma space // Output color is in gamma space as well. */ float3 Vignette_TW3( in float3 gammaColor, in float3 vignetteColor, in float3 vignetteWeights, in float vignetteOpacity, in Texture2D texVignette, in float2 texUV ) { // For coloring vignette float3 vignetteColorGammaSpace = -gammaColor + vignetteColor; // Calculate vignette amount based on color in *LINEAR* color space and vignette weights. float vignetteWeight = dot( GammaToLinear( gammaColor ), vignetteWeights ); // We need to keep vignette weight in [0-1] range vignetteWeight = saturate( 1.0 - vignetteWeight ); // Multiply by opacity vignetteWeight *= vignetteOpacity; // Obtain vignette mask (here is texture; you can also calculate your custom mask here) float sampledVignetteMask = texVignette.Sample( samplerLinearClamp, texUV ).x; // Final (inversed) vignette mask float finalInvVignetteMask = saturate( vignetteWeight * sampledVignetteMask ); // final composite in gamma space float3 Color = vignetteColorGammaSpace * finalInvVignetteMask + gammaColor.rgb; // * uncomment to debug vignette mask: // return 1.0 - finalInvVignetteMask; // Return final color return Color; } 

मुझे आशा है कि आपको अच्छा लगा होगा। आप मेरे HLSLexplorer को भी आज़मा सकते हैं , जिससे मुझे HLSL कोडांतरक कोड को समझने में बहुत मदद मिली।

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

ढाल गणना: बोनस

में बजाय precalculated बनावट नमूने का उपयोग कर के, 2015 "इस Witcher 3" रिवर्स पिक्सेल शेडर में गणना की ढाल में जारी किया। कोडांतरक कोड पर एक नज़र डालें:

  35: add r2.xy, v1.zwzz, l(-0.500000, -0.500000, 0.000000, 0.000000) 36: dp2 r1.w, r2.xyxx, r2.xyxx 37: sqrt r1.w, r1.w 38: mad r1.w, r1.w, l(2.000000), l(-0.550000) 39: mul_sat r2.w, r1.w, l(1.219512) 40: mul r2.z, r2.w, r2.w 41: mul r2.xy, r2.zwzz, r2.zzzz 42: dp4 r1.w, l(-0.100000, -0.105000, 1.120000, 0.090000), r2.xyzw 43: min r1.w, r1.w, l(0.940000) 

हमारे लिए सौभाग्य से, यह काफी सरल है। HLSL पर, यह कुछ इस तरह दिखेगा:

  float TheWitcher3_2015_Mask( in float2 uv ) { float distanceFromCenter = length( uv - float2(0.5, 0.5) ); float x = distanceFromCenter * 2.0 - 0.55; x = saturate( x * 1.219512 ); // 1.219512 = 100/82 float x2 = x * x; float x3 = x2 * x; float x4 = x2 * x2; float outX = dot( float4(x4, x3, x2, x), float4(-0.10, -0.105, 1.12, 0.09) ); outX = min( outX, 0.94 ); return outX; } 

यही है, हम बस केंद्र से कपड़ा तक की दूरी की गणना करते हैं, इसके साथ कुछ जादू करते हैं (गुणन, संतृप्त ...), और फिर ... बहुपद की गणना करें! बहुत खूब।

भाग 5: नशा का प्रभाव

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

शाम:



रात:


सबसे पहले, हम एक दोहरी और घूमती हुई छवि देखते हैं, अक्सर जब आप वास्तविक जीवन में पीते हैं। छवि के केंद्र से एक पिक्सेल को दूर, रोटेशन प्रभाव को मजबूत करता है। मैंने जानबूझकर रात के साथ दूसरा वीडियो पोस्ट किया है, क्योंकि आप तारों पर इस रोटेशन को स्पष्ट रूप से देख सकते हैं (8 अलग-अलग बिंदुओं को देखें?)

नशे के प्रभाव का दूसरा हिस्सा, जो तुरंत ध्यान देने योग्य नहीं हो सकता है, ज़ूम में मामूली बदलाव है। यह केंद्र के पास ध्यान देने योग्य है।

यह शायद स्पष्ट है कि यह प्रभाव एक विशिष्ट पोस्ट-प्रोसेसिंग (पिक्सेल shader) है। हालाँकि, रेंडरिंग पाइपलाइन में इसका स्थान इतना स्पष्ट नहीं हो सकता है। यह पता चला है कि नशा के प्रभाव को तानल सुधार के तुरंत बाद और गति धब्बा से पहले लागू किया जाता है ("नशे में" छवि गति धुंधला के लिए इनपुट है)।

खेल कोडांतरक कोड के साथ शुरू करते हैं:

  ps_5_0 dcl_globalFlags refactoringAllowed dcl_constantbuffer cb0[2], immediateIndexed dcl_constantbuffer cb3[3], immediateIndexed dcl_sampler s0, mode_default dcl_resource_texture2d (float,float,float,float) t0 dcl_input_ps_siv v1.xy, position dcl_output o0.xyzw dcl_temps 8 0: mad r0.x, cb3[0].y, l(-0.100000), l(1.000000) 1: mul r0.yz, cb3[1].xxyx, l(0.000000, 0.050000, 0.050000, 0.000000) 2: mad r1.xy, v1.xyxx, cb0[1].zwzz, -cb3[2].xyxx 3: dp2 r0.w, r1.xyxx, r1.xyxx 4: sqrt r1.z, r0.w 5: mul r0.w, r0.w, l(10.000000) 6: min r0.w, r0.w, l(1.000000) 7: mul r0.w, r0.w, cb3[0].y 8: mul r2.xyzw, r0.yzyz, r1.zzzz 9: mad r2.xyzw, r1.xyxy, r0.xxxx, -r2.xyzw 10: mul r3.xy, r0.xxxx, r1.xyxx 11: mad r3.xyzw, r0.yzyz, r1.zzzz, r3.xyxy 12: add r3.xyzw, r3.xyzw, cb3[2].xyxy 13: add r2.xyzw, r2.xyzw, cb3[2].xyxy 14: mul r0.x, r0.w, cb3[0].x 15: mul r0.x, r0.x, l(5.000000) 16: mul r4.xyzw, r0.xxxx, cb3[0].zwzw 17: mad r5.xyzw, r4.zwzw, l(1.000000, 0.000000, -1.000000, -0.000000), r2.xyzw 18: sample_indexable(texture2d)(float,float,float,float) r6.xyzw, r5.xyxx, t0.xyzw, s0 19: sample_indexable(texture2d)(float,float,float,float) r5.xyzw, r5.zwzz, t0.xyzw, s0 20: add r5.xyzw, r5.xyzw, r6.xyzw 21: mad r6.xyzw, r4.zwzw, l(0.707000, 0.707000, -0.707000, -0.707000), r2.xyzw 22: sample_indexable(texture2d)(float,float,float,float) r7.xyzw, r6.xyxx, t0.xyzw, s0 23: sample_indexable(texture2d)(float,float,float,float) r6.xyzw, r6.zwzz, t0.xyzw, s0 24: add r5.xyzw, r5.xyzw, r7.xyzw 25: add r5.xyzw, r6.xyzw, r5.xyzw 26: mad r6.xyzw, r4.zwzw, l(0.000000, 1.000000, -0.000000, -1.000000), r2.xyzw 27: mad r2.xyzw, r4.xyzw, l(-0.707000, 0.707000, 0.707000, -0.707000), r2.xyzw 28: sample_indexable(texture2d)(float,float,float,float) r7.xyzw, r6.xyxx, t0.xyzw, s0 29: sample_indexable(texture2d)(float,float,float,float) r6.xyzw, r6.zwzz, t0.xyzw, s0 30: add r5.xyzw, r5.xyzw, r7.xyzw 31: add r5.xyzw, r6.xyzw, r5.xyzw 32: sample_indexable(texture2d)(float,float,float,float) r6.xyzw, r2.xyxx, t0.xyzw, s0 33: sample_indexable(texture2d)(float,float,float,float) r2.xyzw, r2.zwzz, t0.xyzw, s0 34: add r5.xyzw, r5.xyzw, r6.xyzw 35: add r2.xyzw, r2.xyzw, r5.xyzw 36: mul r2.xyzw, r2.xyzw, l(0.062500, 0.062500, 0.062500, 0.062500) 37: mad r5.xyzw, r4.zwzw, l(1.000000, 0.000000, -1.000000, -0.000000), r3.zwzw 38: sample_indexable(texture2d)(float,float,float,float) r6.xyzw, r5.xyxx, t0.xyzw, s0 39: sample_indexable(texture2d)(float,float,float,float) r5.xyzw, r5.zwzz, t0.xyzw, s0 40: add r5.xyzw, r5.xyzw, r6.xyzw 41: mad r6.xyzw, r4.zwzw, l(0.707000, 0.707000, -0.707000, -0.707000), r3.zwzw 42: sample_indexable(texture2d)(float,float,float,float) r7.xyzw, r6.xyxx, t0.xyzw, s0 43: sample_indexable(texture2d)(float,float,float,float) r6.xyzw, r6.zwzz, t0.xyzw, s0 44: add r5.xyzw, r5.xyzw, r7.xyzw 45: add r5.xyzw, r6.xyzw, r5.xyzw 46: mad r6.xyzw, r4.zwzw, l(0.000000, 1.000000, -0.000000, -1.000000), r3.zwzw 47: mad r3.xyzw, r4.xyzw, l(-0.707000, 0.707000, 0.707000, -0.707000), r3.xyzw 48: sample_indexable(texture2d)(float,float,float,float) r4.xyzw, r6.xyxx, t0.xyzw, s0 49: sample_indexable(texture2d)(float,float,float,float) r6.xyzw, r6.zwzz, t0.xyzw, s0 50: add r4.xyzw, r4.xyzw, r5.xyzw 51: add r4.xyzw, r6.xyzw, r4.xyzw 52: sample_indexable(texture2d)(float,float,float,float) r5.xyzw, r3.xyxx, t0.xyzw, s0 53: sample_indexable(texture2d)(float,float,float,float) r3.xyzw, r3.zwzz, t0.xyzw, s0 54: add r4.xyzw, r4.xyzw, r5.xyzw 55: add r3.xyzw, r3.xyzw, r4.xyzw 56: mad r2.xyzw, r3.xyzw, l(0.062500, 0.062500, 0.062500, 0.062500), r2.xyzw 57: mul r0.x, cb3[0].y, l(8.000000) 58: mul r0.xy, r0.xxxx, cb3[0].zwzz 59: mad r0.z, cb3[1].y, l(0.020000), l(1.000000) 60: mul r1.zw, r0.zzzz, r1.xxxy 61: mad r1.xy, r1.xyxx, r0.zzzz, cb3[2].xyxx 62: mad r3.xy, r1.zwzz, r0.xyxx, r1.xyxx 63: mul r0.xy, r0.xyxx, r1.zwzz 64: mad r0.xy, r0.xyxx, l(2.000000, 2.000000, 0.000000, 0.000000), r1.xyxx 65: sample_indexable(texture2d)(float,float,float,float) r1.xyzw, r1.xyxx, t0.xyzw, s0 66: sample_indexable(texture2d)(float,float,float,float) r4.xyzw, r0.xyxx, t0.xyzw, s0 67: sample_indexable(texture2d)(float,float,float,float) r3.xyzw, r3.xyxx, t0.xyzw, s0 68: add r1.xyzw, r1.xyzw, r3.xyzw 69: add r1.xyzw, r4.xyzw, r1.xyzw 70: mad r2.xyzw, -r1.xyzw, l(0.333333, 0.333333, 0.333333, 0.333333), r2.xyzw 71: mul r1.xyzw, r1.xyzw, l(0.333333, 0.333333, 0.333333, 0.333333) 72: mul r0.xyzw, r0.wwww, r2.xyzw 73: mad o0.xyzw, cb3[0].yyyy, r0.xyzw, r1.xyzw 74: ret 

दो अलग-अलग निरंतर बफ़र्स का उपयोग यहां किया जाता है। आइए उनके मूल्यों की जाँच करें:



हम उनमें से कुछ में रुचि रखते हैं:

cb0_v0.x -> बीता हुआ समय (सेकंड में)
cb0_v1.xyzw - व्यूपोर्ट का आकार और व्यूपोर्ट आकार (उर्फ "पिक्सेल आकार") के
पारस्परिक: cb3_v0.x - पिक्सेल के चारों ओर घूमने पर, हमेशा 1.0 का मान होता है।
cb3_v0.y - नशा के प्रभाव की भयावहता। इसे चालू करने के बाद, यह पूरी ताकत से काम नहीं करता है, लेकिन धीरे-धीरे 0.0 से 1.0 तक बढ़ जाता है।
cv3_v1.xy - पिक्सेल ऑफ़सेट्स (नीचे इस पर और अधिक)। यह एक पाप / ब्रह्मांड जोड़ी है, इसलिए यदि आप चाहें तो आप shader में sincos (समय) का उपयोग कर सकते हैं।
cb3_v2.xy प्रभाव का केंद्र है, आमतौर पर फ्लोट 2 (0.5, 0.5)।
यहां हम यह समझने पर ध्यान केंद्रित करना चाहते हैं कि क्या हो रहा है, और न केवल नेत्रहीन रूप से शेडर को फिर से लिखना।

हम पहली लाइनों के साथ शुरू करेंगे:

  ps_5_0 0: mad r0.x, cb3[0].y, l(-0.100000), l(1.000000) 1: mul r0.yz, cb3[1].xxyx, l(0.000000, 0.050000, 0.050000, 0.000000) 2: mad r1.xy, v1.xyxx, cb0[1].zwzz, -cb3[2].xyxx 3: dp2 r0.w, r1.xyxx, r1.xyxx 4: sqrt r1.z, r0.w 

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

लाइनें 2-4: सबसे पहले, हम वेक्टर को प्रभाव के केंद्र से बनावट के यूवी निर्देशांक तक गणना करते हैं। फिर हम दूरी के वर्ग (3) और सरल दूरी (4) (केंद्र से टेक्सेल तक) की गणना करते हैं

ज़ूम बनावट निर्देशांक

आइए निम्नलिखित कोड कोड को देखें:

  8: mul r2.xyzw, r0.yzyz, r1.zzzz 9: mad r2.xyzw, r1.xyxy, r0.xxxx, -r2.xyzw 10: mul r3.xy, r0.xxxx, r1.xyxx 11: mad r3.xyzw, r0.yzyz, r1.zzzz, r3.xyxy 12: add r3.xyzw, r3.xyzw, cb3[2].xyxy 13: add r2.xyzw, r2.xyzw, cb3[2].xyxy 

चूंकि वे इस तरह से पैक किए जाते हैं, हम फ्लोट की केवल एक जोड़ी का विश्लेषण कर सकते हैं।

शुरुआत के लिए, r0.yz "रोटेशन ऑफ़सेट" हैं, r1.z केंद्र से टेक्सेल की दूरी है, r1.xy केंद्र से टेक्सेल तक वेक्टर है, r0.x "ज़ूम कारक" है।

इसे समझने के लिए, अब मान लेते हैं कि zoomFactor = 1.0, यानी आप निम्नलिखित लिख सकते हैं:

  8: mul r2.xyzw, r0.yzyz, r1.zzzz 9: mad r2.xyzw, r1.xyxy, r0.xxxx, -r2.xyzw 13: add r2.xyzw, r2.xyzw, cb3[2].xyxy r2.xy = (texel - center) * zoomFactor - rotationOffsets * distanceFromCenter + center; 

लेकिन ZoomFactor = 1.0:

  r2.xy = texel - center - rotationOffsets * distanceFromCenter + center; r2.xy = texel - rotationOffsets * distanceFromCenter; 

इसी तरह r3.xy के लिए:

  10: mul r3.xy, r0.xxxx, r1.xyxx 11: mad r3.xyzw, r0.yzyz, r1.zzzz, r3.xyxy 12: add r3.xyzw, r3.xyzw, cb3[2].xyxy r3.xy = rotationOffsets * distanceFromCenter + zoomFactor * (texel - center) + center 

लेकिन ZoomFactor = 1.0: महान। यही है, इस समय हमारे पास अनिवार्य रूप से वर्तमान बनावट (टेक्सल), रोटेशन ऑफ़सेट है, लेकिन ज़ूमफ़ैक्टर के बारे में क्या है? लाइन 0. देखें। वास्तव में, zoomFactor = 1.0 - 0.1 * drunkAmount। अधिकतम नशे के लिए, ज़ूमफ़ैक्टर का मान 0.9 होना चाहिए, और ज़ूम के साथ बनावट निर्देशांक की गणना अब इस प्रकार की जाती है:

r3.xy = rotationOffsets * distanceFromCenter + texel - center + center r3.xy = texel + rotationOffsets * distanceFromCenter

  baseTexcoordsA = 0.9 * texel + 0.1 * center + rotationOffsets * distanceFromCenter baseTexcoordsB = 0.9 * texel + 0.1 * center - rotationOffsets * distanceFromCenter 

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

बनावट ऑफसेट

कोडांतरक कोड में संपूर्ण टुकड़ा:

  2: mad r1.xy, v1.xyxx, cb0[1].zwzz, -cb3[2].xyxx 3: dp2 r0.w, r1.xyxx, r1.xyxx 5: mul r0.w, r0.w, l(10.000000) 6: min r0.w, r0.w, l(1.000000) 7: mul r0.w, r0.w, cb3[0].y 14: mul r0.x, r0.w, cb3[0].x 15: mul r0.x, r0.x, l(5.000000) // texcoords offset intensity 16: mul r4.xyzw, r0.xxxx, cb3[0].zwzw // texcoords offset 

एक निश्चित ढाल बनाता है, चलो इसे "विस्थापन तीव्रता मुखौटा" कहते हैं। वास्तव में, यह दो अर्थ देता है। पहला r0.w में है (हम इसे बाद में उपयोग करेंगे) और दूसरा r0.x (पंक्ति 15) में 5 गुना मजबूत है। उत्तरार्द्ध वास्तव में टेक्सल आकार के लिए एक कारक के रूप में कार्य करता है, इसलिए यह पूर्वाग्रह बल को प्रभावित करता है।

रोटेशन-संबंधी नमूनाकरण

अगला, बनावट के नमूने की एक श्रृंखला की जाती है। वास्तव में, 8 नमूनों की 2 श्रृंखला का उपयोग किया जाता है, प्रत्येक "पक्ष" के लिए। HLSL में, आप इसे इस प्रकार लिख सकते हैं:

  static const float2 pointsAroundPixel[8] = { float2(1.0, 0.0), float2(-1.0, 0.0), float2(0.707, 0.707), float2(-0.707, -0.707), float2(0.0, 1.0), float2(0.0, -1.0), float2(-0.707, 0.707), float2(0.707, -0.707) }; float4 colorA = 0; float4 colorB = 0; int i=0; [unroll] for (i = 0; i < 8; i++) { colorA += TexColorBuffer.Sample( samplerLinearClamp, baseTexcoordsA + texcoordsOffset * pointsAroundPixel[i] ); } colorA /= 16.0; [unroll] for (i = 0; i < 8; i++) { colorB += TexColorBuffer.Sample( samplerLinearClamp, baseTexcoordsB + texcoordsOffset * pointsAroundPixel[i] ); } colorB /= 16.0; float4 rotationPart = colorA + colorB; 

चाल यह है कि हम बेसटैक्सकोर्ड्स / बी को यूनिट सर्कल पर पड़े अतिरिक्त ऑफसेट से जोड़ते हैं, जो पहले वर्णित "बनावट के निर्देशांक की तीव्रता की तीव्रता" से कई गुना अधिक है। पिक्सेल के केंद्र से दूर, पिक्सेल के चारों ओर वृत्त का त्रिज्या जितना बड़ा है - हम इसे 8 बार नमूना लेते हैं, जो सितारों पर स्पष्ट रूप से दिखाई देता है। PointsAroundPixel मान (45 डिग्री के गुणक):


सिंगल सर्कल

जूम संबंधित नमूना

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

  56: mad r2.xyzw, r3.xyzw, l(0.062500, 0.062500, 0.062500, 0.062500), r2.xyzw // the rotation part is stored in r2 register 57: mul r0.x, cb3[0].y, l(8.000000) 58: mul r0.xy, r0.xxxx, cb3[0].zwzz 59: mad r0.z, cb3[1].y, l(0.020000), l(1.000000) 60: mul r1.zw, r0.zzzz, r1.xxxy 61: mad r1.xy, r1.xyxx, r0.zzzz, cb3[2].xyxx 62: mad r3.xy, r1.zwzz, r0.xyxx, r1.xyxx 63: mul r0.xy, r0.xyxx, r1.zwzz 64: mad r0.xy, r0.xyxx, l(2.000000, 2.000000, 0.000000, 0.000000), r1.xyxx 65: sample_indexable(texture2d)(float,float,float,float) r1.xyzw, r1.xyxx, t0.xyzw, s0 66: sample_indexable(texture2d)(float,float,float,float) r4.xyzw, r0.xyxx, t0.xyzw, s0 67: sample_indexable(texture2d)(float,float,float,float) r3.xyzw, r3.xyxx, t0.xyzw, s0 68: add r1.xyzw, r1.xyzw, r3.xyzw 69: add r1.xyzw, r4.xyzw, r1.xyzw 

हम देखते हैं कि तीन अलग-अलग बनावट कॉल हैं, अर्थात्, तीन अलग-अलग बनावट निर्देशांक हैं। आइए विश्लेषण करते हैं कि कैसे बनावट निर्देशांक उनसे गणना की जाती है। लेकिन पहले, हम इस भाग के लिए इनपुट दिखाते हैं:

  float zoomInOutScalePixels = drunkEffectAmount * 8.0; // line 57 float2 zoomInOutScaleNormalizedScreenCoordinates = zoomInOutScalePixels * texelSize.xy; // line 58 float zoomInOutAmplitude = 1.0 + 0.02*cos(time); // line 59 float2 zoomInOutfromCenterToTexel = zoomInOutAmplitude * fromCenterToTexel; // line 60 

इनपुट के बारे में कुछ शब्द। हम टेक्सल्स में ऑफसेट की गणना करते हैं (उदाहरण के लिए, 8.0 * टेक्सल आकार), जिसे बाद में बेस यूवी निर्देशांक में जोड़ा जाता है। आयाम केवल ज़ूम की भावना देने के लिए 0.98 और 1.02 के बीच होता है, जैसा कि घुमाव का प्रदर्शन करने वाले हिस्से में ज़ूमफ़ैक्टोर करता है।

चलिए पहली जोड़ी से शुरू करते हैं - r1.xy (पंक्ति 61)

  r1.xy = fromCenterToTexel * amplitude + center r1.xy = (TextureUV - Center) * amplitude + Center // you can insert here zoomInOutfromCenterToTexel r1.xy = TextureUV * amplitude - Center * amplitude + Center r1.xy = TextureUV * amplitude + Center * 1.0 - Center * amplitude r1.xy = TextureUV * amplitude + Center * (1.0 - amplitude) r1.xy = lerp( TextureUV, Center, amplitude); 

वह है:

 float2 zoomInOutBaseTextureUV = lerp(TextureUV, Center, amplitude); 

चलो दूसरी जोड़ी की जाँच करें - r3.xy (पंक्ति 62)

  r3.xy = (amplitude * fromCenterToTexel) * zoomInOutScaleNormalizedScreenCoordinates + zoomInOutBaseTextureUV 

वह है:

  float2 zoomInOutAddTextureUV0 = zoomInOutBaseTextureUV + zoomInOutfromCenterToTexel*zoomInOutScaleNormalizedScreenCoordinates; 

आइए तीसरी जोड़ी की जाँच करें - r0.xy (लाइनें 63-64)

  r0.xy = zoomInOutScaleNormalizedScreenCoordinates * (amplitude * fromCenterToTexel) * 2.0 + zoomInOutBaseTextureUV 

वह है:

  float2 zoomInOutAddTextureUV1 = zoomInOutBaseTextureUV + 2.0*zoomInOutfromCenterToTexel*zoomInOutScaleNormalizedScreenCoordinates 

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

यह सब एक साथ

रखना तो, इस समय हमारे पास r2 रजिस्टर में रोटेशन का परिणाम है और r1 रजिस्टर में तीन गुना जूम अनुरोध हैं। आइए कोडांतरक कोड की अंतिम पंक्तियों को देखें:

  70: mad r2.xyzw, -r1.xyzw, l(0.333333, 0.333333, 0.333333, 0.333333), r2.xyzw 71: mul r1.xyzw, r1.xyzw, l(0.333333, 0.333333, 0.333333, 0.333333) 72: mul r0.xyzw, r0.wwww, r2.xyzw 73: mad o0.xyzw, cb3[0].yyyy, r0.xyzw, r1.xyzw 74: ret 

अतिरिक्त इनपुट के बारे में: r0.w को लाइन 7 से लिया गया है, यह हमारा तीव्रता मास्क है, और cb3 [0]। यह नशे के प्रभाव का परिमाण है।

आइए देखें कि यह कैसे काम करता है। मेरा पहला दृष्टिकोण पाशविक बल था:

  float4 finalColor = intensityMask * (rotationPart - zoomingPart); finalColor = drunkIntensity * finalColor + zoomingPart; return finalColor; 

लेकिन क्या हो, कोई भी इस तरह के शेड्स नहीं लिखता । मैंने कागज के साथ एक पेंसिल ली और यह सूत्र लिखा:

  finalColor = effectAmount * [intensityMask * (rotationPart - zoomPart)] + zoomPart finalColor = effectAmount * intensityMask * rotationPart - effectAmount * intensityMask * zoomPart + zooomPart 

टी कहाँ = effectAmount * intensityMask

तो, हम पाते हैं:

  finalColor = t * rotationPart - t * zoomPart + zoomPart finalColor = t * rotationPart + zoomPart - t * zoomPart finalColor = t * rotationPart + (1.0 - t) * zoomPart finalColor = lerp( zoomingPart, rotationPart, t ) 

और हम निम्नलिखित पर आते हैं:

  finalColor = lerp(zoomingPart, rotationPart, intensityMask * drunkIntensity); 

हां, लेख का यह हिस्सा बहुत विस्तृत निकला, लेकिन हम अंत में समाप्त हो गए! व्यक्तिगत रूप से, मैंने लिखने की प्रक्रिया में कुछ सीखा, मुझे आशा है कि आप भी करेंगे!

यदि आप रुचि रखते हैं, तो पूर्ण एचएलएसएल स्रोत यहां उपलब्ध हैं । मैंने अपने HLSLexplorer के साथ उनका परीक्षण किया , और हालांकि मूल shader के साथ कोई प्रत्यक्ष एक-से-एक पत्राचार नहीं है, अंतर इतने छोटे (एक पंक्ति कम) हैं कि मैं विश्वास के साथ कह सकता हूं कि यह काम करता है। पढ़ने के लिए धन्यवाद!