Unity IOS shader vector array bug

Unity 2022.3.33f1

For some reason modifying MeshRenderer material shader SetVectorArray doesn't work on IOS, but it works on android and windows builds!!

I was working on Fog Of War, where I used SimpleFOW by Revision3 it's very simple FOW shader where it manipulates the alpha based on UVs vertices.

This is the FogOfWarShaderControl.cs script

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace SimpleFOW
{
    [RequireComponent(typeof(MeshRenderer))]
    public class FogOfWarShaderControl : MonoBehaviour
    {
        public static FogOfWarShaderControl Instance { get; private set; }

        [Header("Maximum amount of revealing points")]
        [SerializeField] private uint maximumPoints = 512;

        [Header("Game Camera")]
        [SerializeField] private Camera mainCamera;

        private List<Vector4> points = new List<Vector4>();

        private Vector2 meshSize, meshExtents;

        private Vector4[] sendBuffer;

        private MeshRenderer meshRenderer;

        private void Awake()
        {
            Instance = this;

            Init();
        }

        // Initialize required variables
        public void Init()
        {
            meshRenderer = GetComponent<MeshRenderer>();
            meshExtents = meshRenderer.bounds.extents;
            meshSize = meshRenderer.bounds.size;

            points = new List<Vector4>();
            sendBuffer = new Vector4[maximumPoints];
        }

        // Transform world point to UV coordinate of FOW mesh
        public Vector2 WorldPointToMeshUV(Vector2 wp)
        {
            Vector2 toRet = Vector2.zero;

            toRet.x = (transform.position.x - wp.x + meshExtents.x) / meshSize.x;
            toRet.y = (transform.position.y - wp.y + meshExtents.y) / meshSize.y;

            return toRet;
        }

        // Show or hide FOW
        public void SetEnabled(bool on)
        {
            meshRenderer.enabled = on;
        }

        // Add revealing point to FOW renderer if amount of points is lower than MAX_POINTS
        public void AddPoint(Vector2 worldPoint)
        {
            if (points.Count < maximumPoints)
            {
                points.Add(WorldPointToMeshUV(worldPoint));
            }
        }

        // Remove FOW revealing point
        public void RemovePoint(Vector2 worldPoint)
        {
            if (worldPoint == new Vector2(0, 0))
            {
                return;
            }

            if (points.Contains(WorldPointToMeshUV(worldPoint)))
            {
                points.Remove(WorldPointToMeshUV(worldPoint));
            }
        }

        // Send any change to revealing point list to shader for rendering
        public void SendPoints()
        {
            points.ToArray().CopyTo(sendBuffer, 0);

            meshRenderer.material.SetVectorArray("_PointArray", sendBuffer);
            meshRenderer.material.SetInt("_PointCount", points.Count);
        }

        // Send new range value to shader
        public void SendRange(float range)
        {
            meshRenderer.material.SetFloat("_RadarRange", range);
        }

        // Send new scale value to shader
        public void SendScale(float scale)
        {
            meshRenderer.material.SetFloat("_Scale", scale);
        }
    }
}

And this is the FogOfWar.shader

Shader "Revision3/FogOfWar"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "black" {}
        _PointCount("Point count", Range(0,512)) = 0
        _Scale("Scale", Float) = 1.0
        _RadarRange("Range", Float) = .5
        _MaxAlpha("Maximum Alpha", Float) = 1.0
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" }
        LOD 100

        ZWrite Off
        Blend SrcAlpha OneMinusSrcAlpha

        Pass
        {
            CGPROGRAM

            #pragma vertex vert
            #pragma fragment frag
            // make fog work
            #pragma multi_compile_fog

            #include "UnityCG.cginc"

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

            struct v2f
            {
                float2 uv : TEXCOORD0;
                UNITY_FOG_COORDS(1)
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;

            float _RadarRange;
            uint _PointCount;
            float _Scale;
            float _MaxAlpha;

            float2 _PointArray[512];

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

            float getDistance(float2 pa[512], float2 uv) {

                float cdist = 99999.0;


                for (uint i = 0; i < _PointCount; i++) {
                    cdist = min(cdist, distance(pa[i]*_Scale, uv));
                }


                return cdist;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // sample the texture
                fixed4 col = tex2D(_MainTex, i.uv);

                i.uv *= _Scale;

                if (_PointCount > 0)
                    col.w = min(_MaxAlpha, max(0.0f, getDistance(_PointArray, i.uv) - _RadarRange));
                else
                    col.w = _MaxAlpha;

                return col;
            }
            ENDCG
        }
    }
}

Now I create a gameobject called FogOfWar as follows

And then in Unit.cs script and Building.cs script I add the following logic

private Vector3 lastPos;

private void Update()
{
    if (lastPos != transform.position)
    {
        FogOfWarShaderControl.Instance.RemovePoint(lastPos);
        FogOfWarShaderControl.Instance.AddPoint(transform.position);

        lastPos = transform.position;

        FogOfWarShaderControl.Instance.SendPoints();
    }
}

Now this gives me the effect of FOW as follows on IOS

where the result should be as follows on other devices

I don't know what causes this to happen only on IOS devices.

The logic works fine on android/windows/Linux/editor but not IOS devices.

So why metal API doesn't support shader set vector array?!