आज हम डायरेक्टएक्स में पोस्ट-प्रोसेसिंग इमेज में लगे रहेंगे।

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

इन सभी प्रभावों को स्वयं देखा जा सकता है, कंप्यूटर से दूर होकर रात में बाहर जाना।

परिणामस्वरूप, हमें निम्न जैसा कुछ मिलता है ( पूर्ण स्क्रीन पर देखें! ):

पहले: सुस्त पोलिश शूटर


के बाद: IGF फाइनलिस्ट और सभी E3 पुरस्कारों के विजेता

ट्रेनिंग

पहला कदम यह तय करना है कि हम किस प्रभाव को प्राप्त करना चाहते हैं। मैंने निम्नलिखित भागों में सभी प्रसंस्करण को तोड़ दिया:

• कम प्रकाश क्षेत्रों में रंग धारणा का नुकसान
• वहां धुंधली दृष्टि
• थोड़ा शोर (ibid)
• मध्यम और कम रोशनी में लंबी दूरी की दृष्टि हानि

कार्यान्वयन

हम Unity3D प्रो के तहत लिखेंगे, पोस्टप्रोसेसिंग के लिए एक shader के रूप में।

सीधे shader में आगे बढ़ने से पहले, हम एक छोटी स्क्रिप्ट लिखेंगे जो इस समान shader के माध्यम से स्क्रीन बफर चलाता है:

using UnityEngine; [ExecuteInEditMode] public class HumanEye : MonoBehaviour { public Shader Shader; public float LuminanceThreshold; public Texture Noise; public float NoiseAmount = 0.5f, NoiseScale = 2; private Camera mainCam; private Material material; private const int PASS_MAIN = 0; void Start () { mainCam = camera; mainCam.depthTextureMode |= DepthTextureMode.DepthNormals; material = new Material (Shader); } void OnRenderImage (RenderTexture source, RenderTexture destination) { material.SetFloat("_LuminanceThreshold", LuminanceThreshold); material.SetFloat ("_BlurDistance", 0.01f); material.SetFloat ("_CamDepth", mainCam.far); material.SetTexture ("_NoiseTex", Noise); material.SetFloat ("_Noise", NoiseAmount); material.SetFloat ("_NoiseScale", NoiseScale); material.SetVector("_Randomness", Random.insideUnitSphere); Graphics.Blit (source, destination, material, PASS_MAIN); } } 

यहाँ हम सिर्फ shader पैरामीटर को उपयोगकर्ता परिभाषित और हमारे shader के माध्यम से स्क्रीन बफ़र को फिर से प्रस्तुत करते हैं।

अब चलो व्यापार के लिए नीचे उतरो।

चरों और स्थिरांक की घोषणाएँ:

 sampler2D _CameraDepthNormalsTexture; float4 _CameraDepthNormalsTexture_ST; sampler2D _MainTex; float4 _MainTex_ST; sampler2D _NoiseTex; float4 _NoiseTex_ST; float4 _Randomness; uniform float _BlurDistance, _LuminanceThreshold, _CamDepth, _Noise, _NoiseScale; #define DEPTH_BLUR_START 3 #define FAR_BLUR_START 40 #define FAR_BLUR_LENGTH 20 

वर्टेक्स शेडर मानक है और कोई असामान्य परिवर्तन नहीं करता है। सबसे दिलचस्प हिस्सा पिक्सेल shader में शुरू होता है।

पहले, चलो वर्तमान पिक्सेल का मूल्य चुनें, और इसके अलावा, उसी पिक्सेल के लिए "धुंधली" मान:

 struct v2f { float4 pos : POSITION; float2 uv : TEXCOORD0; float2 uv_depth : TEXCOORD1; }; half4 main_frag (v2f i) : COLOR { half4 cColor = tex2D(_MainTex, i.uv); half4 cBlurred = blur(_MainTex, i.uv, _BlurDistance); 

ब्लर () फ़ंक्शन द्वारा एक "धुंधला" मान प्राप्त किया जाता है, जो हमारे आस-पड़ोस के कई पिक्सेल का चयन करता है और उनके मूल्यों को औसत करता है:

 inline half4 blur (sampler2D tex, float2 uv, float dist) { #define BLUR_SAMPLE_COUNT 16 //     float-! const float3 RAND_SAMPLES[16] = { float3(0.2196607,0.9032637,0.2254677), ....  14  .... float3(0.2448421,-0.1610962,0.1289366), }; half4 result = 0; for (int s = 0; s < BLUR_SAMPLE_COUNT; ++s) result += tex2D(tex, uv + RAND_SAMPLES[s].xy * dist); result /= BLUR_SAMPLE_COUNT; return result; } 

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

 half kLum = (cColor.r + cColor.g + cColor.b) / 3; kLum = 1 - clamp(kLum / _LuminanceThreshold, 0, 1); 

चमक पर kLum की निर्भरता कुछ इस तरह दिखाई देगी:



हमारे दृश्य के लिए क्लम मान इस तरह दिखते हैं (सफेद - 1, काला - 0):



यहां यह स्पष्ट रूप से देखा गया है कि उज्ज्वल क्षेत्रों (लालटेन और प्रबुद्ध घास का प्रभामंडल) शून्य के बराबर kum है और हमारे प्रभाव को उन पर लागू नहीं किया जाएगा।

मीटर में स्क्रीन की सतह से पिक्सेल तक की दूरी गहराई बनावट (जेड-बफर) से प्राप्त की जा सकती है, जो कि स्पष्ट रूप से उपलब्ध है जब डिफेंडर प्रतिपादन।

 float depth; float3 normal; DecodeDepthNormal(tex2D(_CameraDepthNormalsTexture, i.uv_depth), depth, normal); depth *= _CamDepth; // depth in meters 

KDepth गुणांक निकट की काली वस्तुओं को धुंधला करने की डिग्री निर्धारित करेगा, और kFarBlur - दूरी के अन्य सभी:

 #define DEPTH_BLUR_START 3 #define FAR_BLUR_START 40 #define FAR_BLUR_LENGTH 20 half kDepth = clamp(depth - DEPTH_BLUR_START, 0, 1); half kFarBlur = clamp((depth - FAR_BLUR_START) / FAR_BLUR_LENGTH, 0, 1); 

दूरी से दोनों गुणांक के रेखांकन समान दिखते हैं और केवल पैमाने में भिन्न होते हैं:


KFarBlur मान:



और अब - जादू! हम पिछले तीन के आधार पर कुल पिक्सेल कलंक गुणांक की गणना करते हैं:

 half kBlur = clamp(kLum * kDepth + kFarBlur, 0, 1); 

डार्क पिक्सल्स को कई मीटर (DEPTH_BLUR_START) की दूरी से शुरू किया जाएगा, और दूर की वस्तुएं - प्रकाश की परवाह किए बिना।



हम में रंग के नुकसान की डिग्री "प्रकाश" (आधा kDesaturate = kLum) की डिग्री के बराबर होगी।

अब यह सामान्य, धुंधले और काले और सफेद पिक्सल्स को मिलाने और अंतिम रंग की गणना करने के लिए बना हुआ है:

 half kDesaturate = kLum; half4 result = cColor; result = (1 - kBlur) * result + kBlur * cBlurred; half resultValue = result; result = (1 - kDesaturate) * result + kDesaturate * resultValue; return result; 

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

 half noiseValue = tex2D(_NoiseTex, i.uv * _NoiseScale + _Randomness.xy); half kNoise = kLum * _Noise; 

यहां हम स्क्रिप्ट द्वारा प्रदान की गई _Randomness वेक्टर का उपयोग करके _NoiseTex बनावट (फ़ोटोशॉप से ​​गॉसियन शोर से भरा) से एक यादृच्छिक चर का चयन करते हैं, जो प्रत्येक फ्रेम पर बदल जाएगा।

हम अपने पिक्सेल में परिणामी यादृच्छिक मूल्य को मिलाते हैं:

 result *= (1 - kNoise + noiseValue * kNoise); 

एक बोनस के रूप में - एक लघु वीडियो और स्वयं shader :



अद्यतन : सही, मानव लेंस flares: