मैं क्वांटम ब्रेक के विरूपण कण प्रभाव को कैसे दोहरा सकता हूं?


68

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

record_2018_02_05_16_34_26_307

record_2018_02_01_22_27_44_971


4
"इस प्रश्न पर पर्याप्त ध्यान नहीं दिया गया है।" ?
एलेक्जेंडर Vaillancourt

@AlexandreVaillancourt मैं सिर्फ अधिक देखे जाने इस सवाल का पिन और ध्यान आकर्षित क्योंकि मुझे लगता है कि यह useful.I इनाम कारणों पर बेहतर कारण नहीं मिला, तो वहाँ एक समस्या मैं अपने reason.thanks बदल जाएगा है
सैयद मोर्तेज़ा Kamali

2
बाउंसियों का उद्देश्य वास्तव में केवल "पिन" सवाल नहीं है; आपका कहा गया तर्क कुछ हद तक असभ्य है। बाउंटीज़ का उद्देश्य उन प्रश्नों पर ध्यान आकर्षित करना है, जिन्हें उत्तर की आवश्यकता है या मौजूदा उत्तरों को पुरस्कृत करने के लिए, जो आप नहीं कर रहे हैं। समुदाय को जो विषय उपयोगी और रोचक लगे, उन्हें पुरस्कृत करने के लिए पहले से ही मैकेनिज्म (HNQ, जो कि आपके कई पोस्ट हिट हैं) मौजूद हैं।
जोश

2
लोभी मत बनो। आपको पहले से ही पर्याप्त विचार और वोट मिले
कैसनोवा

@JoshPetrie आप सही कह रहे हैं मुझे खेद है कि मैं इस राज्य को नहीं दोहराता हूँ। मुझे शर्म आती है ताकि आप बिना प्रतिष्ठा लौटे सुविधाओं से मेरे प्रश्न को हटा सकें। मैं ऐसा सिर्फ इसलिए करता हूं क्योंकि मुझे लगा कि शायद मैं दूसरों की मदद करूंगा।
सीयड मोर्टेज़ा कमली

जवाबों:


101

पिरामिड कण

एकता डिफ़ॉल्ट कण का आकार क्वाड है। पहले आपको पिरामिड ऑब्जेक्ट का उपयोग करके इस आकृति को पिरामिड में बदलने की आवश्यकता है या एक ज्यामितीय शेडर के साथ क्वाड्र्स को पिरामिड में बदल देता है

छवि

AWD

अपवर्तन

टूटे हुए कांच के प्रभाव ( अपवर्तन ) को बनाने के लिए आप GrabPass { "TextureName" }स्क्रीन सामग्री को बनावट में ले जा सकते हैं ।

GrabPass एक विशेष पास प्रकार है - यह स्क्रीन की सामग्रियों को पकड़ लेता है जहां ऑब्जेक्ट एक बनावट में तैयार होने वाला है। इस बनावट का उपयोग बाद में पास में उन्नत छवि आधारित प्रभाव करने के लिए किया जा सकता है।

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

record_2018_02_03_23_09_06_370

Shader "Smkgames/GlassRefraction"
{
    Properties{
        _Refraction("Refraction",Float) = 0.05
        _Alpha("Alpha",Range(0,1)) = 1
    }
    SubShader
    {
Tags {"Queue"="Transparent" "RenderType"="Transparent"}

        Blend SrcAlpha OneMinusSrcAlpha

        GrabPass
        {
            "_GrabTexture"
        }

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
            };

            struct v2f
            {
                float4 grabPos : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };
            sampler2D _MainTex;
            float _Alpha,_Refraction;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.grabPos = ComputeGrabScreenPos(o.vertex);
                return o;
            }

            sampler2D _GrabTexture;

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2Dproj(_GrabTexture, i.grabPos+_Refraction);
                return float4(col.rgb,_Alpha);

            }
            ENDCG
        }
    }
}

मेष मानदंडों का उपयोग करना

आइए एक ऐसे शेडर के साथ आगे बढ़ें जो विश्व अंतरिक्ष में मेष मानदंडों को प्रदर्शित करता है। मैंने इसका इस्तेमाल किया क्योंकि मैं तीन आयामी टूटी हुई आकृति देखना चाहता था।

normals

record_2018_02_05_18_06_09_41

record_2018_02_03_23_19_06_705

    Shader "Smkgames/BrokenGlass3D"
{
    Properties{
        _MainTex("MainTex",2D) = "white"{}
        _Alpha("Alpha",Float) = 1
    }
    SubShader
    {
Tags {"Queue"="Transparent" "RenderType"="Transparent"}
 Blend SrcAlpha OneMinusSrcAlpha 


        GrabPass
        {
            "_GrabTexture"
        }

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 grabPos : TEXCOORD0;
                float3 normal :NORMAL;
            };

            struct v2f
            {
                float4 grabPos : TEXCOORD0;
                float4 vertex : SV_POSITION;
                half3 worldNormal :TEXCOORD1;

            };
            sampler2D _MainTex;
            float _Intensity,_Alpha;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.grabPos = ComputeGrabScreenPos(o.vertex);
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                return o;
            }

            sampler2D _GrabTexture;

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 c = 0;
                c.rgb = i.worldNormal*0.5+0.5;
                float4 distortion = tex2D(_MainTex,i.grabPos)+_Intensity;
                fixed4 col = tex2Dproj(_GrabTexture, i.grabPos+c.r);
                return float4(col.rgb,_Alpha);
            }
            ENDCG
        }
    }
}

गर्मी विकृति

हीट विरूपण बनाने के लिए आप फ्लो मैप का उपयोग कर सकते हैं

एक प्रवाह-मानचित्र एक बनावट है जो एक बनावट में 2d दिशात्मक जानकारी संग्रहीत करता है। पिक्सेल का रंग निर्धारित करता है कि वह आधार के रूप में uv-निर्देशांक बनावट का उपयोग किस दिशा में कर रहा है। अधिक रंग वहाँ आनुपातिक गति तेज है। उदाहरण हरा इसे ऊपर-बाएं जाने के लिए कहता है, केंद्र तटस्थ है, और लाल दाएं नीचे जाएगा। यह पानी जैसी तरल सामग्री के लिए एक उपयोगी तकनीक है, और सिर्फ एक पैन्टर नोड के लिए एक उपयोगी विकल्प है।

flow_map

heatdistortion

    Shader "Smkgames/HeatDistortion"
{
    Properties{
        _DistortionMap("DistortionMap",2D) = "white"{}
        _Intensity("Intensity",Float) = 50
        _Mask("Mask",2D) = "white"{}
        _Alpha("Alpha",Range(0,1)) = 1
    }
    SubShader
    {
Tags {"Queue"="Transparent" "RenderType"="Transparent"}

        GrabPass
        {
            "_GrabTexture"
        }

        Blend SrcAlpha OneMinusSrcAlpha

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
            };

            struct v2f
            {
                float4 grabPos : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };
            sampler2D _Mask,_DistortionMap;
            float _Alpha,_Refraction;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.grabPos = ComputeGrabScreenPos(o.vertex);
                return o;
            }

            sampler2D _GrabTexture;
            float _Intensity;

            fixed4 frag (v2f i) : SV_Target
            {
                float mask = tex2D(_Mask,i.grabPos);
                mask = step(mask,0.5);
                //mask = smoothstep(mask,0,0.4);
                float4 distortion = tex2D(_DistortionMap,i.grabPos+_Time.y)+_Intensity;
                fixed4 col = tex2Dproj(_GrabTexture, i.grabPos*distortion);
                return float4(col.rgb,mask*_Alpha);

            }
            ENDCG
        }
    }
}

सामान्य उपयोग करके एक और उदाहरण:

कट आउट

normalmap

smoketile_normal १

Shader "Smkgames/HeatDistortion2" {
Properties {
        _CutOut ("CutOut (A)", 2D) = "black" {}
        _BumpMap ("Normalmap", 2D) = "bump" {}
        _BumpAmt ("Distortion", Float) = 10
}

Category {

    Tags { "Queue"="Transparent"  "IgnoreProjector"="True"  "RenderType"="Opaque" }
    Blend SrcAlpha OneMinusSrcAlpha
    Cull Off 
    Lighting Off 
    ZWrite Off 
    Fog { Mode Off}

    SubShader {
        GrabPass {                          
            "_GrabTexture"
        }
        Pass {

CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma fragmentoption ARB_precision_hint_fastest
#pragma multi_compile_particles
#include "UnityCG.cginc"

struct appdata_t {
    float4 vertex : POSITION;
    float2 texcoord: TEXCOORD0;
};

struct v2f {
    float4 vertex : POSITION;
    float4 uvgrab : TEXCOORD0;
    float2 uvbump : TEXCOORD1;
    float2 uvcutout : TEXCOORD2;
};

sampler2D _BumpMap,_CutOut,_GrabTexture;
float _BumpAmt;
float4 _GrabTexture_TexelSize;
float4 _BumpMap_ST,_CutOut_ST;

v2f vert (appdata_t v)
{
    v2f o;
    o.vertex = UnityObjectToClipPos(v.vertex);
    o.uvgrab.xy = (float2(o.vertex.x, o.vertex.y*-1) + o.vertex.w) * 0.5;
    o.uvgrab.zw = o.vertex.zw;
    o.uvbump = TRANSFORM_TEX( v.texcoord, _BumpMap );
    o.uvcutout = TRANSFORM_TEX( v.texcoord, _CutOut );
    return o;
}



half4 frag( v2f i ) : COLOR
{
    half2 bump = UnpackNormal(tex2D( _BumpMap, i.uvbump )).rg;
    float2 offset = bump * _BumpAmt * _GrabTexture_TexelSize.xy;
    i.uvgrab.xy = offset * i.uvgrab.z + i.uvgrab.xy;

    half4 col = tex2Dproj( _GrabTexture, UNITY_PROJ_COORD(i.uvgrab));
    fixed4 cut = tex2D(_CutOut, i.uvcutout);
    fixed4 emission = col;
    emission.a = (cut.a);
    return emission;
}
ENDCG
        }
    }

  }
}

RGB विभाजन

यदि आप अपने पहले gif पर ध्यान देते हैं तो आप थोड़ा RGB विभाजन देख सकते हैं।

u_rgb_seperation_ar

Shader "Hidden/RgbSplit"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _NoiseTex1 ("Noise Texture A", 2D) = "white" {}
        _NoiseTex2 ("Noise Texture B", 2D) = "white" {}
    }
    SubShader
    {

        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;
            };

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

            sampler2D _MainTex,_NoiseTex1,_NoiseTex2;
            float3 colorSplit(float2 uv, float2 s)
{
    float3 color;
    color.r = tex2D(_MainTex, uv - s).r;
    color.g = tex2D(_MainTex, uv    ).g;
    color.b = tex2D(_MainTex, uv + s).b;
    return color;
}

float2 interlace(float2 uv, float s)
{
    uv.x += s * (4.0 * frac((uv.y) / 2.0) - 1.0);
    return uv;
}

    fixed4 frag (v2f i) : SV_Target
    {

    float t = _Time.y;

    float s = tex2D(_NoiseTex1, float2(t * 0.2, 0.5)).r;

    i.uv = interlace(i.uv, s * 0.005);
    float r = tex2D(_NoiseTex2, float2(t, 0.0)).x;

    float3 color = colorSplit(i.uv, float2(s * 0.02, 0.0));

    return float4(color, 1.0);

            }
            ENDCG
        }
    }
}

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

https://www.fxguide.com/featured/time-for-destruction-the-tech-of-quantum-break/

स्रोत गितुब पर


47
मैं उत्सुक हूं, क्या आपने इन जैसी तकनीकों को साझा करने के लिए डेवलपर ब्लॉग स्थापित करने पर विचार किया है? मैं उस तरह एक संसाधन की सदस्यता लेंगे। :)
DMGregory

7
मैंने दूसरा सुझाव दिया! मैं आपकी प्रतिक्रियाओं के लिए हर दिन वेबसाइट की निगरानी करता हूं, क्योंकि आपका दृष्टिकोण हमेशा रचनात्मक, विस्तृत और समझने में सरल है। आपके द्वारा दिए गए उदाहरण भी बहुत मदद करते हैं।
20

4
आपके RGB विभाजन प्रभाव के बारे में: मैं चश्मा पहनता हूं और हमेशा प्राकृतिक रूप से उत्पन्न होने वाले समान प्रभाव का अनुभव करता हूं, जो आंखों के पर्दे के अंतर के साथ भिन्न होता है। उसी तरह से कि 3 डी ग्लास कितने दूर है के विभिन्न संकेतों के बीच एक बेमेल का कारण बनता है, आपका प्रभाव एक विस्तार के साथ हस्तक्षेप करता है कि मेरा मस्तिष्क यह अनुमान लगाने के लिए व्याख्या करता है कि स्क्रीन मेरी आंख से कितनी दूर है। यह बहुत अप्रिय है, मतली के मुद्दे पर। यदि आप इसका उपयोग करना चुनते हैं तो कृपया इसे वैकल्पिक बनाएं!
एओयूइड

1
@Aoeuid FWIW, यह सुधारात्मक दृष्टि के बिना भी लोगों के लिए बेहद अप्रिय है :)
मैक्स

@DMGregory हां: डि एक साइट नहीं इसलिए मैं यहाँ मेरी तकनीक का हिस्सा मैं विकासशील ब्लॉग या site.If करने के लिए अपने समर्थन की जरूरत तुम मेरा साथ मैं सहायक होगा https://www.patreon.com/SeyedMortezaKamaly
सैयद मोर्तेज़ा Kamali
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.