unity – OUT.worldPosition effect on shader in unity2020.2

I am trying to follow a shader tutorial from 2016 for unity.

I reached the point where the author is distorting the text by changing OUT.wordPosition

    v2f vert(appdata_t v)
    {
        v2f OUT;
        UNITY_SETUP_INSTANCE_ID(v);
        UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);
        float4 vPosition = UnityObjectToClipPos(v.vertex);

        float4 offset = float4(
            0, 
            tex2Dlod(_NoiseTex, float4(v.vertex.x / 1000, 0,0,0)).r,
            0, 
            0);
        OUT.worldPosition = v.vertex + offset;

OUT.vertex = vPosition ;

I am trying to follow this code but any changes I make to OUT.worldPosition has no effect. Even if I just set it to 0 the test still displays without any change.

I know that the rest of my code works correctly. If I instead of OUT.worldPosition change OUT.vertex there is an imact on the text, if not the desired effect.

The biggest difference between me and the tutorial author is that he is using unity 5.3.4 for the base code of his shader. As I am using Unity 2020.2 I used the Unity 2020.2 as the base of my shader code, and worked around the differences.

For some reason I just can’t manipulate worldPosition .

Here is the tutorial I am following
https://www.youtube.com/watch?v=VZOetdCvFTg

Snippet of his working code
enter image description here

Are there changes in Unity 202 requiring me to do anything different? Am I doing something else wrong?

Here is my complete code for the shader

Shader "Unlit/TextShader"
{
    Properties
    {
        (PerRendererData) _MainTex ("Sprite Texture", 2D) = "white" {}
        _Color ("Tint", Color) = (1,1,1,1)

        _StencilComp ("Stencil Comparison", Float) = 8
        _Stencil ("Stencil ID", Float) = 0
        _StencilOp ("Stencil Operation", Float) = 0
        _StencilWriteMask ("Stencil Write Mask", Float) = 255
        _StencilReadMask ("Stencil Read Mask", Float) = 255

        _ColorMask ("Color Mask", Float) = 15
        _NoiseTex ("Noise Texture",2D)="white"

        _DistortionDamer ("Distortion Damper",float)=10
        _DistortionSpread ("Distortion Spread",float)=50

        (Toggle(UNITY_UI_ALPHACLIP)) _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
    }

    SubShader
    {
        Tags
        {
            "Queue"="Transparent"
            "IgnoreProjector"="True"
            "RenderType"="Transparent"
            "PreviewType"="Plane"
            "CanUseSpriteAtlas"="True"
        }

        Stencil
        {
            Ref (_Stencil)
            Comp (_StencilComp)
            Pass (_StencilOp)
            ReadMask (_StencilReadMask)
            WriteMask (_StencilWriteMask)
        }

        Cull Off
        Lighting Off
        ZWrite Off
        ZTest (unity_GUIZTestMode)
        Blend One OneMinusSrcAlpha
        ColorMask (_ColorMask)

        Pass
        {
            Name "Default"
        CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma target 2.0

            #include "UnityCG.cginc"
            #include "UnityUI.cginc"

            #pragma multi_compile_local _ UNITY_UI_CLIP_RECT
            #pragma multi_compile_local _ UNITY_UI_ALPHACLIP

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

            struct v2f
            {
                float4 vertex   : SV_POSITION;
                fixed4 color    : COLOR;
                float2 texcoord  : TEXCOORD0;
                float4 worldPosition : TEXCOORD1;
                half4  mask : TEXCOORD2;
                UNITY_VERTEX_OUTPUT_STEREO
            };

            sampler2D _MainTex;
            sampler2D _NoiseTex;
            float _DistortionDamer;
            float _DistortionSpread;


            fixed4 _Color;
            fixed4 _TextureSampleAdd;
            float4 _ClipRect;
            float4 _MainTex_ST;
            float _UIMaskSoftnessX;
            float _UIMaskSoftnessY;

            v2f vert(appdata_t v)
            {
                v2f OUT;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);
                float4 vPosition = UnityObjectToClipPos(v.vertex);
    
                float4 offset = float4(
                    0, 
                    tex2Dlod(_NoiseTex, float4(v.vertex.x / 100, 0,0,0)).r,
                    0, 
                    0);
                OUT.worldPosition = v.vertex + offset;         
                OUT.vertex = vPosition ;

                float2 pixelSize = vPosition.w;
                pixelSize /= float2(1, 1) * abs(mul((float2x2)UNITY_MATRIX_P, _ScreenParams.xy));

                float4 clampedRect = clamp(_ClipRect, -2e10, 2e10);
                float2 maskUV = (v.vertex.xy - clampedRect.xy) / (clampedRect.zw - clampedRect.xy);
                OUT.texcoord = TRANSFORM_TEX(v.texcoord.xy, _MainTex);
                OUT.mask = half4(v.vertex.xy * 2 - clampedRect.xy - clampedRect.zw, 0.25 / (0.25 * half2(_UIMaskSoftnessX, _UIMaskSoftnessY) + abs(pixelSize.xy)));

                OUT.color = v.color * _Color;
                return OUT;
            }

            fixed4 frag(v2f IN) : SV_Target
            {
    
                half4 color = IN.color * (tex2D(_MainTex, IN.texcoord) + _TextureSampleAdd);
                #ifdef UNITY_UI_CLIP_RECT
                half2 m = saturate((_ClipRect.zw - _ClipRect.xy - abs(IN.mask.xy)) * IN.mask.zw);
                color.a *= m.x * m.y;
                #endif

                #ifdef UNITY_UI_ALPHACLIP
                clip (color.a - 0.001);
                #endif

                color.rgb *= color.a;

                return color;
            }
        ENDCG
        }
    }
}