How to add a disintegrate to a shader?

Question

I have found a force field shader online, and in the video the force field can disintegrate/dissolve. But the source file doesn't add that, and someone commented saying that but they said they weren't going to add it because it is a shader mask and under procedural properties. The person who made it speaks a different language and doesn't usally reply so that's why I'm here. https://www.youtube.com/watch?v=wbL2FCxlCe4. There is the link to the video. So basically I'm asking if someone can help me add a disintegration shader to this current shader. I don't code with shaders and don't plan on learning because other people that I work with are in that area of specialties. They don't understand though. the script is:

 Shader "Unlit/ShieldFX"
 {
     Properties
     {
         _MainColor("MainColor", Color) = (1,1,1,1)
         _MainTex ("Texture", 2D) = "white" {}
         _Fresnel("Fresnel Intensity", Range(0,200)) = 3.0
         _FresnelWidth("Fresnel Width", Range(0,2)) = 3.0
         _Distort("Distort", Range(0, 100)) = 1.0
         _IntersectionThreshold("Highlight of intersection threshold", range(0,1)) = .1 //Max difference for intersections
         _ScrollSpeedU("Scroll U Speed",float) = 2
         _ScrollSpeedV("Scroll V Speed",float) = 0
         //[ToggleOff]_CullOff("Cull Front Side Intersection",float) = 1
         _SliceGuide ("Slice Guide (RGB)", 2D) = "white" {}
         _SliceAmount ("Slice Amount", Range(0.0, 1.0)) = 0.5
     }
         
     SubShader
     { 
         Tags{ "Queue" = "Overlay" "IgnoreProjector" = "True" "RenderType" = "Transparent" }
 
         GrabPass{ "_GrabTexture" }
         Pass
         {
 
             Lighting Off ZWrite On
             Blend SrcAlpha OneMinusSrcAlpha
             Cull Off
 
             CGPROGRAM
             
 
             #pragma vertex vert
             #pragma fragment frag
             #include "UnityCG.cginc"
 
             struct appdata
             {
                 fixed4 vertex : POSITION;
                 fixed4 normal: NORMAL;
                 fixed3 uv : TEXCOORD0;
             };
 
             struct v2f
             {
                 fixed2 uv : TEXCOORD0;
                 fixed4 vertex : SV_POSITION;
                 fixed3 rimColor :TEXCOORD1;
                 fixed4 screenPos: TEXCOORD2;
             };
 
             sampler2D _MainTex, _CameraDepthTexture, _GrabTexture;
             fixed4 _MainTex_ST,_MainColor,_GrabTexture_ST, _GrabTexture_TexelSize;
             fixed _Fresnel, _FresnelWidth, _Distort, _IntersectionThreshold, _ScrollSpeedU, _ScrollSpeedV;
 
             v2f vert (appdata v)
             {
                 v2f o;
                 o.vertex = UnityObjectToClipPos(v.vertex);
                 o.uv = TRANSFORM_TEX(v.uv, _MainTex);
 
                 //scroll uv
                 o.uv.x += _Time * _ScrollSpeedU;
                 o.uv.y += _Time * _ScrollSpeedV;
 
                 //fresnel 
                 fixed3 viewDir = normalize(ObjSpaceViewDir(v.vertex));
                 fixed dotProduct = 1 - saturate(dot(v.normal, viewDir));
                 o.rimColor = smoothstep(1 - _FresnelWidth, 1.0, dotProduct) * .5f;
                 o.screenPos = ComputeScreenPos(o.vertex);
                 COMPUTE_EYEDEPTH(o.screenPos.z);//eye space depth of the vertex 
                 return o;
             }
             
             fixed4 frag (v2f i,fixed face : VFACE) : SV_Target
             {
                 //intersection
                 fixed intersect = saturate((abs(LinearEyeDepth(tex2Dproj(_CameraDepthTexture,i.screenPos).r) - i.screenPos.z)) / _IntersectionThreshold);
 
                 fixed3 main = tex2D(_MainTex, i.uv);
                 //distortion
                 i.screenPos.xy += (main.rg * 2 - 1) * _Distort * _GrabTexture_TexelSize.xy;
                 fixed3 distortColor = tex2Dproj(_GrabTexture, i.screenPos);
                 distortColor *= _MainColor * _MainColor.a + 1;
 
                 //intersect hightlight
                 i.rimColor *= intersect * clamp(0,1,face);
                 main *= _MainColor * pow(_Fresnel,i.rimColor) ;
                 
                 //lerp distort color & fresnel color
                 main = lerp(distortColor, main, i.rimColor.r);
                 main += (1 - intersect) * (face > 0 ? .03:.3) * _MainColor * _Fresnel;
                 return fixed4(main,.9);
             }
 
              //if you're not planning on using shadows, remove "addshadow" for better performance
 
             ENDCG
         }
     }
 }

Answer 1

The effect you see in the video is nothing in the shader. He uses procedurally generated textures and that mask slider is part of the texture generator and not of the shader. So this is actually done on the CPU. The texture is generated from hexagonal shapes and the mask simply deactivates some of them based on the slider.

You can't really get the same result just by some shader logic (unless you actually generate this pattern inside the shader itself). You can get a similar effect by using a predefined masking texture with several random "hot spots" which have a gradient to "0". By using this mask texture along with a bias offset you can get a "1" everywhere when the slider is at "1" (so the mask is basically "overbright" and just 1 everywhere) or you get a "0" everywhere when the slider is at "0" (which would be like "darkening" the mask so it's 0 everywhere). In between you would have a gradient between your hotspots so the texture doesn't fade out at once

edit
I just got home and quickly created this script to generate a random mask texture, and this is the modified ShieldFx shader.

To sum up the changes: I add two new properties to the shader:

 _MaskTex ("MaskTexture", 2D) = "white" {}
 _Disolve ("Disolve", Range(0,1)) = 0.0

_MaskTex willl hold our generated mask texture and _Disolve controls if the field is visible (0) or completely disolved (1)

Inside the CG code we have to declare our properties. I just added the _MaskTex sampler and the _Disolve value simply at the end here:

 sampler2D _MainTex, _CameraDepthTexture, _GrabTexture, _MaskTex;
 fixed _Fresnel, _FresnelWidth, _Distort, _IntersectionThreshold, _ScrollSpeedU, _ScrollSpeedV, _Disolve;

Finally inside the Fragment shader we calculate a masking multiplier like this:

 fixed mask = clamp(tex2D(_MaskTex, i.uv).a+0.004,0,1) - _Disolve>0?1:0;

which is finally used to scale the alpha value of our resulting color:

 return fixed4(main,.9 * mask);

Note that the masking texture is a pure alpha texture. So only the alpha channel is actually used. Of course instead of the random generated mask texture you can create your own mask texture. Generally alpha values closer to "0" will disolve first and alpha values close to 1 will disolve last.

The random generated mask texture simply uses all 255 values randomly spreaded across the texture. So while the _Disolve value ramps from 0 to 1 random "parts" of the texture will disappear. Keep in mind when you use a small mask size the "areas" will be larger. Also keep in mind that the minimum texture size would be 16x16 pixels, otherwise you don't get the full spectrum. That means when you use an 8x8 mask the shield will be completely disolved after just "0.25" and not at "1.0"

Finally here you can see how the result looks like as animated GIF:

ps: Just in case it's not obvious, you can modify the _Disolve property of the material through script like that:

 Material mat; // needs to reference your material that is using the shader
 
 mat.SetFloat("_Disolve", yourValue)

How to add a disintegrate to a shader?

1 Reply

Your answer

Follow this Question

Related Questions