मैं "दीवारों के पीछे देखने" प्रभाव कैसे बना सकता हूं?


103

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

खिलाड़ियों के दीवारों के पीछे जाने पर एक गतिशील छप मास्क बनाकर मैं इस प्रभाव को कैसे दोहरा सकता हूं?

आप इस YouTube वीडियो के माध्यम से गति में वांछित प्रभाव देख सकते हैं ।

छवि


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

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

@AlexandreVaillancourt ओह माफ करना, मैं यह नहीं जानता था, मैं सिर्फ अपने सवाल के लिए एक विकल्प जोड़ देता हूं क्योंकि मुझे श्रृंखला के प्रश्न पसंद नहीं हैं। संशोधन के लिए धन्यवाद ...
Seyed Morteza Kamali

जवाबों:


163

मास्किंग

इस आशय को बनाने के लिए, आप एक स्टैंसिल बफर का उपयोग करके वस्तुओं को मुखौटा कर सकते हैं।

स्टेंसिल बफर एक सामान्य उद्देश्य बफर है जो आपको स्क्रीन पर खींचे गए प्रत्येक पिक्सेल के लिए एक अतिरिक्त 8 बिट पूर्णांक (यानी 0-255 से मान) स्टोर करने की अनुमति देता है। जिस प्रकार शेड्स स्क्रीन पर पिक्सेल के रंग को निर्धारित करने के लिए RGB मानों की गणना करते हैं, और गहराई बफ़र के लिए खींचे गए उन पिक्सेल की गहराई के लिए z मान, वे उन प्रत्येक पिक्सेल के स्टेंसिल बफर के लिए एक मनमाना मूल्य भी लिख सकते हैं। उन स्टैंसिल मूल्यों को फिर से समझा जा सकता है और बाद के शेडर द्वारा तुलना करके यह निर्धारित किया जाता है कि स्क्रीन पर पिक्सल कैसे कंपोज़ किए जाने चाहिए।

https://docs.unity3d.com/Manual/SL-Stencil.html

https://alastaira.wordpress.com/2014/12/27/using-the-stencil-buffer-in-unity-free/

http://www.codingwithunity.com/2016/01/stencil-buffer-shader-for-special.html

छवि

मास्क स्टैंसिल:

Stencil 
{
    Ref 1 // ReferenceValue = 1
    Comp NotEqual // Only render pixels whose reference value differs from the value in the buffer.
}

दीवार स्टैंसिल:

Stencil
{
    Ref 1 // ReferenceValue = 1
    Comp Always // Comparison Function - Make the stencil test always pass.
    Pass Replace // Write the reference value into the buffer.
}

चलो लागू करते हैं।

मास्क के रूप में इसका उपयोग करें:

Shader "Custom/SimpleMask"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _CutOff("CutOff", Range(0,1)) = 0
    }
    SubShader
    {
        LOD 100
        Blend One OneMinusSrcAlpha
        Tags { "Queue" = "Geometry-1" }  // Write to the stencil buffer before drawing any geometry to the screen
        ColorMask 0 // Don't write to any colour channels
        ZWrite Off // Don't write to the Depth buffer
        // Write the value 1 to the stencil buffer
        Stencil
        {
            Ref 1
            Comp Always
            Pass Replace
        }

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            float _CutOff;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);

                o.uv = TRANSFORM_TEX(v.uv, _MainTex);

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                float dissolve = step(col, _CutOff);
                clip(_CutOff-dissolve);
                return float4(1,1,1,1)*dissolve;
            }
            ENDCG
        }
    }
}

दीवार के रूप में इसका उपयोग करें:

Shader "Custom/Wall" {
    Properties {
        _Color ("Color", Color) = (1,1,1,1)
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _Glossiness ("Smoothness", Range(0,1)) = 0.5
        _Metallic ("Metallic", Range(0,1)) = 0.0
    }
    SubShader {
        Blend SrcAlpha OneMinusSrcAlpha
        Tags { "RenderType"="Opaque" }
        LOD 200

        Stencil {
            Ref 1
            Comp NotEqual
        }

        CGPROGRAM
        // Physically based Standard lighting model, and enable shadows on all light types
        #pragma surface surf Standard fullforwardshadows

        // Use shader model 3.0 target, to get nicer looking lighting
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input {
            float2 uv_MainTex;
        };

        half _Glossiness;
        half _Metallic;
        fixed4 _Color;

        void surf (Input IN, inout SurfaceOutputStandard o) {
            // Albedo comes from a texture tinted by color
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
            o.Albedo = c.rgb;
            // Metallic and smoothness come from slider variables
            o.Metallic = _Metallic;
            o.Smoothness = _Glossiness;
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

प्रभाव विश्लेषण

यदि आप एक प्रक्रियात्मक बनावट रखना चाहते हैं , तो आपको कुछ शोर की आवश्यकता है।

छवि आप इस shaderToy में shader देख सकते हैं ।

इस प्रभाव को बनाने के लिए, यूवी निर्देशांक का उपयोग करने के बजाय, ध्रुवीय निर्देशांक का उपयोग करें और फिर इसे शोर बनावट पर सेट करें।

Uvs को आम तौर पर एक ग्रिड में फैशन की तरह रखा जाता है, जैसे कि पिक्सेल न स्क्रीन (X = चौड़ाई, Y = ऊंचाई)। ध्रुवीय निर्देशांक, हालांकि, x और ya बिट का अलग-अलग उपयोग करते हैं। एक यह निर्धारित करता है कि यह सर्कल के केंद्र से कितना दूर है और दूसरा डिग्री को निर्धारित करता है, 0-1 डिग्री से, जो आपके लिए आवश्यक है।

1600px-sf_radialuvs

Shader "Smkgames/NoisyMask" {
    Properties {
        _MainTex ("MainTex", 2D) = "white" {}
        _Thickness ("Thickness", Range(0, 1)) = 0.25
        _NoiseRadius ("Noise Radius", Range(0, 1)) = 1
        _CircleRadius("Circle Radius", Range(0, 1)) = 0.5
        _Speed("Speed", Float) = 0.5
    }
    SubShader {
        Tags {"Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent"}
        ZWrite Off 
        Blend SrcAlpha OneMinusSrcAlpha 
        Cull Off

        Pass {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
            #pragma target 3.0
            uniform sampler2D _MainTex; uniform float4 _MainTex_ST;
            uniform float _Thickness,_NoiseRadius,_CircleRadius,_Speed;

            struct VertexInput {
                float4 vertex : POSITION;
                float2 texcoord0 : TEXCOORD0;
            };
            struct VertexOutput {
                float4 pos : SV_POSITION;
                float2 uv0 : TEXCOORD0;
                float4 posWorld : TEXCOORD1;

            };
            VertexOutput vert (VertexInput v) {
                VertexOutput o = (VertexOutput)0;
                o.uv0 = v.texcoord0;

                o.pos = UnityObjectToClipPos(v.vertex);
                o.posWorld = mul(unity_ObjectToWorld, v.vertex);
                return o;
            }
            float4 frag(VertexOutput i, float facing : VFACE) : COLOR {

                float2 uv = (i.uv0*2.0+-1.0); // Remapping uv from [0,1] to [-1,1]
                float circleMask = step(length(uv),_NoiseRadius); // Making circle by LENGTH of the vector from the pixel to the center
                float circleMiddle = step(length(uv),_CircleRadius); // Making circle by LENGTH of the vector from the pixel to the center
                float2 polaruv = float2(length(uv),((atan2(uv.g,uv.r)/6.283185)+0.5)); // Making Polar
                polaruv += _Time.y*_Speed/10;
                float4 _MainTex_var = tex2D(_MainTex,TRANSFORM_TEX(polaruv, _MainTex)); // BackGround Noise
                float Noise = (circleMask*step(_MainTex_var.r,_Thickness)); // Masking Background Noise
                float3 finalColor = float3(Noise,Noise,Noise);
                return fixed4(finalColor+circleMiddle,(finalColor+circleMiddle).r);
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

एक अन्य समाधान वर्ली शोर का उपयोग कर रहा है:

2018-01-05_8-16-16

आप इस shaderToy में shader देख सकते हैं


Metaball

फिर मैं इस लेख से मेटाबॉल प्रभाव जोड़ता हूं : img


बिल बोर्डिंग

वहाँ और भी है...

यदि आप अपना मुखौटा घुमाना चाहते हैं, तो अपने कैमरे को देखने के लिए, आप बिल बोर्ड का उपयोग कर सकते हैं :

 output.pos = mul(UNITY_MATRIX_P, 
              mul(UNITY_MATRIX_MV, float4(0.0, 0.0, 0.0, 1.0))
              + float4(input.vertex.x, input.vertex.y, 0.0, 0.0));

यह बिल बोर्डिंग वाला मास्क है:

Shader "Custom/Mask/SimpleMaskBillBoard"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _CutOff("CutOff", Range(0,1)) = 0
        _Radius("Radius", Range(0,1)) = 0.2
        _Speed("speed", Float) = 1
        _ScaleX ("Scale X", Float) = 1.0
        _ScaleY ("Scale Y", Float) = 1.0
    }
    SubShader
    {
        LOD 100
        Blend One OneMinusSrcAlpha
        Tags { "Queue" = "Geometry-1" }  // Write to the stencil buffer before drawing any geometry to the screen
        ColorMask 0 // Don't write to any colour channels
        ZWrite Off // Don't write to the Depth buffer

        // Write the value 1 to the stencil buffer
        Stencil
        {
            Ref 1
            Comp Always
            Pass Replace
        }

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            float _CutOff;
            float _Speed;
            float _Radius;
            float _ScaleX,_ScaleY;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = mul(UNITY_MATRIX_P, 
                    mul(UNITY_MATRIX_MV, float4(0.0, 0.0, 0.0, 1.0))
                    + float4(v.vertex.x, v.vertex.y, 0.0, 0.0)
                    * float4(_ScaleX, _ScaleY, 1.0, 1.0));

                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                float dissolve = step(col, _CutOff);
                clip(_CutOff-dissolve);
                return dissolve;
            }
            ENDCG
        }
    }
}

अंतिम परिणाम:

2018-01-04_20-18-39

स्रोत उपलब्ध है: https://github.com/smkplus/Divinity-Origin-Sin-2


उपयोगी कड़ियाँ

मुझे एक अच्छा ट्यूटोरियल मिला जिसने इस प्रभाव को दुनिया को भंग करके लागू किया:

Image1

संसार को भंग करना भाग 1

संसार को भंग करना भाग 2

छवि

Shader "Custom/DissolveBasedOnViewDistance" {
    Properties{
        _MainTex("Albedo (RGB)", 2D) = "white" {}
        _Center("Dissolve Center", Vector) = (0,0,0,0)
        _Interpolation("Dissolve Interpolation", Range(0,5)) = 0.8
        _DissTexture("Dissolve Texture", 2D) = "white" {}
    }

        SubShader{
        Tags { "RenderType" = "Opaque" }
        LOD 200


            CGPROGRAM

        #pragma surface surf Standard vertex:vert addshadow

        #pragma target 3.0

        struct Input {
            float2 uv_MainTex;
            float2 uv_DissTexture;
            float3 worldPos;
            float viewDist;
        };



        sampler2D _MainTex;
        sampler2D _DissTexture;
        half _Interpolation;
        float4 _Center;


        // Computes world space view direction
        // inline float3 WorldSpaceViewDir( in float4 v )
        // {
        //     return _WorldSpaceCameraPos.xyz - mul(_Object2World, v).xyz;
        // }


        void vert(inout appdata_full v,out Input o){
            UNITY_INITIALIZE_OUTPUT(Input,o);

         half3 viewDirW = WorldSpaceViewDir(v.vertex);
         o.viewDist = length(viewDirW);

        }

        void surf(Input IN, inout SurfaceOutputStandard o) {


            float l = length(_Center - IN.worldPos.xyz);

            clip(saturate(IN.viewDist - l + (tex2D(_DissTexture, IN.uv_DissTexture) * _Interpolation * saturate(IN.viewDist))) - 0.5);

         o.Albedo = tex2D(_MainTex,IN.uv_MainTex);
        }
        ENDCG
        }
        Fallback "Diffuse"
}

एक और स्टैंसिल ट्यूटोरियल:

4 को मृत छोडा

स्टैंसिल ट्यूटोरियल


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

10
@ भुलक्कड़ आप पता लगाने के लिए रेकास्ट का उपयोग कर सकते हैं जब चरित्र दीवारों के पीछे होता है तो मास्क को सक्षम करें।
सैयद मोर्तेजा कमली
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.