Seamless Terrain on Quad Sphere

Hi everybody, I am trying to make a procedural planet using a quad sphere with mapped 3D noise. However, I cannot find anywhere on the internet how to implement the Z component of the 3d noise. If I place in the vertex's position, No result is received. How can I find a z component for a quad sphere?

code here, in case I made an error somewhere.

 using UnityEngine;
 using System.Collections;
 
 public struct PatchConfig
 {
     public string name;
     public Vector3 uAxis;
     public Vector3 vAxis;
     public Vector3 height;
     public PatchConfig(string aName, Vector3 aUAxis, Vector3 aVAxis)
     {
         name = aName;
         uAxis = aUAxis;
         vAxis = aVAxis;
         height = Vector3.Cross(vAxis, uAxis);
     }
 }
 
 public class Sphere : MonoBehaviour
 {
     private static PatchConfig[] patches = new PatchConfig[]
     {
          new PatchConfig("top", Vector3.right, Vector3.forward),
          new PatchConfig("bottom", Vector3.left, Vector3.forward),
          new PatchConfig("left", Vector3.up, Vector3.forward),
          new PatchConfig("right", Vector3.down, Vector3.forward),
          new PatchConfig("front", Vector3.right, Vector3.down),
          new PatchConfig("back", Vector3.right, Vector3.up)
     };
 
     public int uPatchCount = 2;
     public int vPatchCount = 2;
     public int xVertCount = 250;
     public int yVertCount = 250;
     public float radius = 5f;
     public float seed;
     public float scale;
 
     public Material patchMaterial;
 
     void Start()
     {
         GeneratePatches();
     }
     public static float Perlin3d(float x, float y, float z)
     {
         float AB = Mathf.PerlinNoise(x, y);
         float BC = Mathf.PerlinNoise(y, z);
         float AC = Mathf.PerlinNoise(x, z);
 
         float BA = Mathf.PerlinNoise(y, x);
         float CB = Mathf.PerlinNoise(z, y);
         float CA = Mathf.PerlinNoise(z, x);
 
         float ABC = AB + BC + AC + BA + CB + CA;
         return ABC / 6f;
     }
 
     void GeneratePatch(PatchConfig aConf, int u, int v)
     {
         GameObject patch = new GameObject(aConf.name + "_" + u + v);
         MeshFilter mf = patch.AddComponent<MeshFilter>();
         MeshRenderer rend = patch.AddComponent<MeshRenderer>();
 
         patch.AddComponent<regionTexture>();
 
         rend.sharedMaterial = patchMaterial;
         Mesh m = mf.sharedMesh = new Mesh();
         patch.transform.parent = transform;
         patch.transform.localEulerAngles = Vector3.zero;
         patch.transform.localPosition = Vector3.zero;
         Vector2 UVstep = new Vector2(1f / uPatchCount, 1f / vPatchCount);
         Vector2 step = new Vector2(UVstep.x / (xVertCount - 1), UVstep.y / (yVertCount - 1));
         Vector2 offset = new Vector3((-0.5f + u * UVstep.x), (-0.5f + v * UVstep.y));
         Vector3[] vertices = new Vector3[xVertCount * yVertCount];
         Vector3[] normals = new Vector3[vertices.Length];
         Vector2[] uvs = new Vector2[vertices.Length];
         for (int y = 0; y < yVertCount; y++)
         {
             for (int x = 0; x < xVertCount; x++)
             {
                 
                 
                 int i = x + y * xVertCount;
                 Vector2 p = offset + new Vector2(x * step.x, y * step.y);
                 uvs[i] = p + Vector2.one * 0.5f;
                 Vector3 vec = (aConf.uAxis * p.x + aConf.vAxis * p.y + aConf.height * 0.5f);
                 vec = vec.normalized;
                 
                 float xx = (float)vec.x/ (xVertCount*scale);
                 float yy = (float)vec.y / (yVertCount*scale);
                 float zz = (float)vec.z/(yVertCount*scale);
                 
                 
                 
                 vec = vec * (1.0f+Perlin3d(xx+seed,yy+seed,zz+seed));
                 normals[i] = vec;
                 vertices[i] = vec * radius;
 
             }
         }
 
         int[] indices = new int[(xVertCount - 1) * (yVertCount - 1) * 4];
         for (int y = 0; y < yVertCount - 1; y++)
         {
             for (int x = 0; x < xVertCount - 1; x++)
             {
                 int i = (x + y * (xVertCount - 1)) * 4;
                 indices[i] = x + y * xVertCount;
                 indices[i + 1] = x + (y + 1) * xVertCount;
                 indices[i + 2] = x + 1 + (y + 1) * xVertCount;
                 indices[i + 3] = x + 1 + y * xVertCount;
             }
         }
         m.vertices = vertices;
         m.normals = normals;
         m.uv = uvs;
         m.SetIndices(indices, MeshTopology.Quads, 0);
         m.RecalculateBounds();
     }
 
     void GeneratePatches()
     {
         for (int i = 0; i < 6; i++)
         {
             for (int u = 0; u < uPatchCount; u++)
             {
                 for (int v = 0; v < vPatchCount; v++)
                 {
                     GeneratePatch(patches[i], u, v);
                 }
             }
         }
     }
 }

Please help.