Fog of war problem

I have the following "fog of war" script. It works well in hiding what is behind the view obstruction gameObjects (red lines on the image). However, it keeps showing an area that reaches out towards coordinate 0,0,0, completely ignoring the view obstruction. In the attached image, it's the long pointy triangle that reaches up and to the left. What am I doing wrong?

![alt text][1]

     public float viewRadius;
     [Range(0, 360)]
     public float viewAngle;
 
     public LayerMask targetMask;
     public LayerMask obstacleMask;
 
     public List<Transform> visibleTargets = new List<Transform>();
 
     public float meshResolution;
     public int edgeResolveIterations;
     public float edgeDstThreshold;
 
     public MeshFilter viewMeshFilter;
     Mesh viewMesh;
 
     public bool AIUnit;
     public EnemyAI AIStatus;
 
     private void Start()
     {
         AIStatus = GetComponent<EnemyAI>();
         AIUnit = AIStatus.AIUnit;
     
         if (AIUnit == false)
         {
             viewMesh = new Mesh();
             viewMesh.name = "View Mesh";
             viewMeshFilter.mesh = viewMesh;
             StartCoroutine("FindTargetsWithDelay", .2f); //this will start the co-routine every .2 seconds
         }
     }
     IEnumerator FindTargetsWithDelay(float delay) //this will call the FindVisibleTargets co-routine
     {
         if (AIUnit == false)
         {
             while (true)
             {
                 yield return new WaitForSeconds(delay);
                 FindVisibleTargets();
             }
         }
     }
     void LateUpdate()
     {
         if (AIUnit == false)
             DrawFieldOfView();
     }
 
     void FindVisibleTargets()
     {
         if (AIUnit == false) { 
             visibleTargets.Clear();  //this removes visible targets constantly so they aren't all seen as visible over time and you only see ones currently visible
        
         Collider[] targetsInViewRadius = Physics.OverlapSphere(transform.position, viewRadius, targetMask); //transform.position is the center of the sphere
 
         for (int i = 0; i < targetsInViewRadius.Length; i++)
         { Transform target = targetsInViewRadius[i].transform;
             Vector3 dirToTarget = (target.position - transform.position).normalized;
                 if (Vector3.Angle(transform.forward, dirToTarget) < viewAngle / 2)
                 {
                     float dstToTarget = Vector3.Distance(transform.position, target.position);
                     if (!Physics.Raycast(transform.position, dirToTarget, dstToTarget, obstacleMask))
                     {
                         visibleTargets.Add(target);
 
                     }
 
                 }
             }
 
         }
     }
 
    
 
     void DrawFieldOfView()
     {
         int stepCount = Mathf.RoundToInt(viewAngle * meshResolution);
         float stepAngleSize = viewAngle / stepCount;
         List<Vector3> viewPoints = new List<Vector3>();
         ViewCastInfo oldViewCast = new ViewCastInfo();
         for (int i = 0; i <= stepCount; i++)
         {
             float angle = transform.eulerAngles.y - viewAngle / 2 + stepAngleSize * i;
             ViewCastInfo newViewCast = ViewCast(angle);
 
             if (i > 0)
             {
                 bool edgeDstThresholdExceeded = Mathf.Abs (oldViewCast.dst - newViewCast.dst) > edgeDstThreshold;
 
                 if (oldViewCast.hit != newViewCast.hit || (oldViewCast.hit && newViewCast.hit && edgeDstThresholdExceeded))
                 {
                     EdgeInfo edge = FindEdge (oldViewCast, newViewCast);
                     if (edge.pointA != Vector3.zero)
                     {
                         viewPoints.Add (edge.pointA);
                     }
                     if (edge.pointA != Vector3.zero)
                     {
                         viewPoints.Add (edge.pointB);
                     }
                 }
             }
             viewPoints.Add(newViewCast.point);
             oldViewCast = newViewCast;
         }
 
         int vertexCount = viewPoints.Count + 1;
         Vector3[] vertices = new Vector3[vertexCount];
         int[] triangles = new int[(vertexCount - 2) * 3];
 
         vertices[0] = Vector3.zero;
         for (int i = 0; i < vertexCount - 1; i++)
         {
             vertices[i + 1] = transform.InverseTransformPoint(viewPoints[i]);
 
             if (i < vertexCount - 2)
             {
                 triangles[i * 3] = 0;
                 triangles[i * 3 + 1] = i + 1;
                 triangles[i * 3 + 2] = i + 2;
             }
         }
 
         viewMesh.Clear();
         viewMesh.vertices = vertices;
         viewMesh.triangles = triangles;
         viewMesh.RecalculateNormals();
     }
 
     EdgeInfo FindEdge(ViewCastInfo minViewCast, ViewCastInfo maxViewCast)
     {
         float minAngle = minViewCast.angle;
         float maxAngle = maxViewCast.angle;
         Vector3 minPoint = Vector3.zero;
         Vector3 maxPoint = Vector3.zero;
 
         for (int i =0; i < edgeResolveIterations; i++)
         {
             float angle = (minAngle + maxAngle) / 2;
             ViewCastInfo newViewCast = ViewCast(angle);
 
             bool edgeDstThresholdExceeded = Mathf.Abs (minViewCast.dst - newViewCast.dst) > edgeDstThreshold;
             if (newViewCast.hit == minViewCast.hit && !edgeDstThresholdExceeded)
             {
                 minAngle = angle;
                 minPoint = newViewCast.point;
                 }
             else
             {
                 maxAngle = angle;
                 maxPoint = newViewCast.point;
             }
         }
         return new EdgeInfo (minPoint, maxPoint);
     }
 
 
     ViewCastInfo ViewCast(float globalAngle)
     {
         Vector3 dir = DirFromAngle(globalAngle, true);
         RaycastHit hit;
 
         if (Physics.Raycast(transform.position, dir, out hit, viewRadius, obstacleMask))
         {
             return new ViewCastInfo(true, hit.point, hit.distance, globalAngle);
         }
         else
         {
             return new ViewCastInfo(false, transform.position + dir * viewRadius, viewRadius, globalAngle);
         }
     }
 
 
     public Vector3 DirFromAngle(float angleInDegrees, bool angleIsGlobal)
     {
         if (!angleIsGlobal)
         { angleInDegrees += transform.eulerAngles.y; }
         return new Vector3(Mathf.Sin(angleInDegrees * Mathf.Deg2Rad), 0, Mathf.Cos(angleInDegrees * Mathf.Deg2Rad));
     }
 
     public struct ViewCastInfo
     { public bool hit;
         public Vector3 point;
         public float dst;
         public float angle;
 
         public ViewCastInfo(bool _hit, Vector3 _point, float _dst, float _angle)
         {
             hit = _hit;
             point = _point;
             dst = _dst;
             angle = _angle;
 
         }
     }
 
     public struct EdgeInfo
     {
         public Vector3 pointA;
         public Vector3 pointB;
 
         public EdgeInfo(Vector3 _pointA, Vector3 _pointB)
         {
             pointA = _pointA;
             pointB = _pointB;
         }
 
     }
 
         }