private void ConnectTwoCircles(BorderPoint ibp) { InfluenceCircle ibpCircle = ibp.circle; borderPoints_subPolygons.Add(ibpCircle.borderPoints); Destroy(ibpCircle.gameObject); }
bool BorderPointsNormalIntersected(BorderPoint p1, BorderPoint p2, float angle) { if (Vector2.Angle(-p1.normal.xz(), p2.normal.xz()) > angle) { return(false); } Vector3 startMidPoint = Vector3.Lerp(p1.pointA, p1.pointB, 0.5f); Vector3 desiredPos = startMidPoint + p1.normal * 0.3f; //Vector2 instersectPoint = Vector2.zero; float mult = 1; Segment segment_1 = new Segment() { a = startMidPoint.xz(), b = desiredPos.xz(), normal = (Quaternion.Euler(0, -90, 0) * (desiredPos - startMidPoint).normalized).normalized.xz() }; Segment segment_2 = new Segment() { a = p2.pointA.xz(), b = p2.pointB.xz(), normal = p2.normal.xz() }; Vector2 intersectionPoint; if (segment_1.IntersectionWithSegmentWithAccuracy(segment_2, 0.1f, out intersectionPoint)) { return(true); } return(false); }
private void ConnectTwoCircles(float growDist, BorderPoint nearPoint, BorderPoint ibp) { InfluenceCircle ibpCircle = ibp.circle; int indexOf = borderPoints.IndexOf(nearPoint); #region Remove points on intersection radius /* List<BorderPoint> intersectPoints = ibpCircle.borderPoints * .Where(v=>Vector3.Distance(v.pointA, nearPoint.pointA)<growDist/2).ToList(); * foreach( var intersectPoint in intersectPoints ) * { * ibpCircle.borderPoints.Remove( intersectPoint ); * } * * //borderPoints.Remove(nearPoint); * intersectPoints = borderPoints * .Where( v => Vector3.Distance( v.pointA, nearPoint.pointA ) < growDist / 2 ).ToList(); * foreach( var intersectPoint in intersectPoints ) * { * borderPoints.Remove( intersectPoint ); * }*/ #endregion MakeCorrectOrderOnConnect(ibpCircle, nearPoint); borderPoints.InsertRange(indexOf, ibpCircle.borderPoints); //growPoints.AddRange(ibpCircle.growPoints); //borderPoints_subPolygons.Add( ibpCircle.borderPoints ); Destroy(ibpCircle.gameObject); }
public void Test2() { //Arrange string Numer = "NR"; double X = 100.01; double Y = 100.02; byte Rzg = 1; byte Stb = 1; byte Zrd = 1; byte Bpp = 1; int j = 0; BorderPoint[] pkt = new BorderPoint[100]; string[] expected = new string[100]; for (int i = 0; i < 100; i++) { pkt[i] = new BorderPoint(Numer + i, X * i, Y * i, Rzg, Stb, Zrd, Bpp); expected[i] = (Numer + i) + " " + (X * i).ToString("F3") + " " + (Y * i).ToString("F3") + " " + "0" + " " + Zrd.ToString() + " " + Bpp.ToString() + " " + Stb.ToString() + " " + Rzg.ToString(); } // Act foreach (BorderPoint p in pkt) { p.ChangedLine(); //Assert string actual = p.Line; Assert.AreEqual(expected[j], actual, "Nie OK"); j++; } }
bool CheckCorrectOrder(List <BorderPoint> bpPoints, BorderPoint lastBP) { List <BorderPoint> bplist = new List <BorderPoint>(/*ibpCircle.borderPoints*/ bpPoints); BorderPoint cp = bplist.OrderBy(v => Vector3.Distance(v.pointA, lastBP.pointA)).First(); return(bplist.IndexOf(cp) != 0); }
private void SubdSegments(float segementSubdDist) { //float segementSubdDist = InfluenceCirclesManager.SegementSubdDist(); for (var i = 1; i < borderPoints.Count - 1; i++) { //BorderPoint bp = borderPoints[i]; var p1 = borderPoints[i].pointA; var p2 = borderPoints[i - 1].pointA; if (Vector3.Distance(p1, p2) < segementSubdDist /*0.3f*/) { continue; } var pLerp = Vector3.Lerp(p1, p2, 0.5f); int indexOf = i;//borderPoints.IndexOf( bp ); BorderPoint newBorderPoint = new BorderPoint() { pointA = pLerp, pointB = p1, normal = borderPoints[i].normal, //fraction = borderPoints[i].fraction, circle = borderPoints[i].circle, /* nextPoint = borderPoints[i], * prevPoint = borderPoints[i-1]*/ }; //bp.pointB = pLerp; borderPoints.Insert(indexOf, newBorderPoint); //i--; i = 0; } }
public void Init(Region from, Region to, BorderPoint fromPoint, BorderPoint toPoint) { FromRegion = from; ToRegion = to; FromPoint = fromPoint; ToPoint = toPoint; Center = Vector2.Lerp(FromPoint.Position, ToPoint.Position, 0.5f); Angle = Vector2.SignedAngle((toPoint.Position - fromPoint.Position), new Vector2(1, 0)); Length = Vector2.Distance(fromPoint.Position, ToPoint.Position); }
bool PointNotBlocked(BorderPoint p1, BorderPoint p2) { //bool result = false; /* float dist = 0.5f; * bool result = Vector3.Distance(p1.pointA, p2.pointA) < dist || Vector3.Distance(p1.pointA, p2.pointB) < dist || Vector3.Distance(p1.pointB, p2.pointB) < dist || Vector3.Distance(p1.pointB, p2.pointA) < dist; || result = !result; || || if (result == true) return result;*/ Vector3 startMidPoint = Vector3.Lerp(p1.pointA, p1.pointB, 0.5f); Vector3 desiredPos = p1.pointA /*startMidPoint*/ + p1.normal * 0.3f; //Vector2 instersectPoint = Vector2.zero; float mult = 1; Segment segment_1 = new Segment() { a = /*startMidPoint*/ p1.pointA.xz(), b = desiredPos.xz(), //normal = p1.normal.xz() }; Segment segment_2 = new Segment() { a = p2.pointA.xz(), b = p2.pointB.xz(), normal = p2.normal.xz() }; Vector2 intersectionPoint; if (segment_1.IntersectionWithSegmentWithAccuracy(segment_2, 0.01f, out intersectionPoint)) { return(false); } /* if (LineIntersection( * new Vector2( startMidPoint.x, startMidPoint.z) * mult, * new Vector2(desiredPos.x, desiredPos.z) * mult, * new Vector2(p2.pointA.x, p2.pointA.z) * mult, * new Vector2(p2.pointB.x, p2.pointB.z) * mult, * ref instersectPoint * )) * { * return false; * }*/ return(true); }
private void MakeCorrectOrderOnConnect(InfluenceCircle ibpCircle, BorderPoint lastBP) { //BorderPoint lastBP = borderPoints.Last(); //Debug.DrawRay( lastBP.pointA + Vector3.up * 0.25f, Vector3.up * 20, Color.blue, 30 ); while (CheckCorrectOrder(ibpCircle.borderPoints, lastBP) /*ibpCircle.borderPoints[0] is not closest to last*/) { var intersectionFirstPoint = ibpCircle.borderPoints[0]; ibpCircle.borderPoints.Insert(ibpCircle.borderPoints.Count /*- 1*/, intersectionFirstPoint); ibpCircle.borderPoints.RemoveAt(0); } }
/// <summary> /// Finds and returns the center position of a list of connected borders including the angle of the border. /// </summary> public static Tuple <Vector2, float> FindBorderCenter(List <Border> borders) { // Make a dictionary with how many times each border point appears Dictionary <BorderPoint, int> bpOccurences = new Dictionary <BorderPoint, int>(); foreach (Border border in borders) { if (bpOccurences.ContainsKey(border.StartPoint)) { bpOccurences[border.StartPoint]++; } else { bpOccurences.Add(border.StartPoint, 1); } if (bpOccurences.ContainsKey(border.EndPoint)) { bpOccurences[border.EndPoint]++; } else { bpOccurences.Add(border.EndPoint, 1); } } // Take a border point with only 1 occurence as start point BorderPoint currentPoint = bpOccurences.Where(x => x.Value == 1).First().Key; Border currentBorder = borders.Where(x => x.StartPoint == currentPoint || x.EndPoint == currentPoint).First(); // Find center position starting with startPoint float currentDistance = 0f; float targetDistance = borders.Sum(x => x.Length) / 2f; while (currentDistance + currentBorder.Length < targetDistance) { currentDistance += currentBorder.Length; currentPoint = currentBorder.StartPoint == currentPoint ? currentBorder.EndPoint : currentBorder.StartPoint; currentBorder = currentPoint.Borders.Where(x => x != currentBorder && borders.Contains(x)).First(); } float restDistance = targetDistance - currentDistance; float factor = restDistance / currentBorder.Length; if (currentPoint == currentBorder.StartPoint) { return(new Tuple <Vector2, float>(Vector2.Lerp(currentBorder.StartPoint.Position, currentBorder.EndPoint.Position, factor), currentBorder.Angle)); } else { return(new Tuple <Vector2, float>(Vector2.Lerp(currentBorder.EndPoint.Position, currentBorder.StartPoint.Position, factor), currentBorder.Angle)); } }
public void SortBorderPointsList() { List <BorderPoint> dictionaryCopy = new List <BorderPoint>(Points.Values); List <BorderPoint> sortedBorder = new List <BorderPoint>(); sortedBorder.Add(dictionaryCopy[0]); bool isSorted = false; while (!isSorted) { BorderPoint currentPoint = sortedBorder[sortedBorder.Count - 1]; if (currentPoint.neighbours.Count == 1) { break; } foreach (BorderPoint neighbour in currentPoint.neighbours) { if (neighbour == sortedBorder[0] && sortedBorder.Count > Points.Count / 2) { isSorted = true; //sortedBorder.Add(neighbour); break; } if (sortedBorder.Contains(neighbour)) { continue; } else { sortedBorder.Add(neighbour); break; } } if (currentPoint == sortedBorder[sortedBorder.Count - 1]) { break; } } Dictionary <Vector2, BorderPoint> sortedPoints = new Dictionary <Vector2, BorderPoint>(); foreach (BorderPoint sorted in sortedBorder) { if (!sortedPoints.ContainsKey(sorted.coordinates)) { sortedPoints.Add(sorted.coordinates, sorted); } } points = sortedPoints; }
public void Init(GraphConnection connection) { Connection = connection; StartPoint = Connection.StartNode.BorderPoint; EndPoint = Connection.EndNode.BorderPoint; Regions = Connection.Polygons.Select(x => x.Region).ToList(); Center = new Vector2((StartPoint.Position.x + EndPoint.Position.x) / 2, (StartPoint.Position.y + EndPoint.Position.y) / 2); Length = Vector2.Distance(StartPoint.Position, EndPoint.Position); Angle = Vector2.SignedAngle((EndPoint.Position - StartPoint.Position), new Vector2(1, 0)); this.transform.position = new Vector3(Center.x, BorderHeight * 0.5f, Center.y); this.transform.rotation = Quaternion.Euler(0, Angle, 0); this.transform.localScale = new Vector3(Length, BorderHeight, BorderWidth); }
public void Test1() { //Arrange string Numer = "NR1"; double X = 100.01; double Y = 100.02; byte Rzg = 1; byte Stb = 1; byte Zrd = 1; byte Bpp = 1; string expected = Numer + " " + X.ToString("F3") + " " + Y.ToString("F3") + " " + "0" + " " + Zrd.ToString() + " " + Bpp.ToString() + " " + Stb.ToString() + " " + Rzg.ToString(); BorderPoint pkt = new BorderPoint(Numer, X, Y, Rzg, Stb, Zrd, Bpp); // Act pkt.ChangedLine(); //Assert string actual = pkt.Line; Assert.AreEqual(expected, actual, "Nie OK"); }
/* public void GrowAllGrowPoints(float growDist) * { * for (var i = 0; i < growPoints.Count; i++) * { * Vector3 growPoint = growPoints[i]; * Grow(growDist, growPoint); * } * }*/ public void Grow(float growDist, Vector3 centerOfMass) { #region Remove parallel border points /* for( var i = 0; i < borderPoints.Count; i++ ) * { * var bp = borderPoints[i]; * BorderPoint firstOrDefault = borderPoints.FirstOrDefault(v =>v!= bp && BorderPointsNormalIntersected(bp, v, 20)); * if( firstOrDefault != null ) * { * borderPoints.Remove( firstOrDefault ); * borderPoints.Remove( bp ); * * i = -1; * } * }*/ #endregion borderPoints_subPolygons = new List <List <BorderPoint> >() { borderPoints }; List <BorderPoint> vertices = new List <BorderPoint>(borderPoints); if (vertices.Count < 1) { return; } #region Calc grow points var allSceneBorderPoints = allInfluenceCircles .Where(v => v != this) .SelectMany(v => v.borderPoints).ToList(); var allSceneBorderPoints_NotThisFraction = allSceneBorderPoints .Where(c => c.circle.fraction != fraction).ToList(); var notBlocked_BP_Points = vertices .Where(v => allSceneBorderPoints_NotThisFraction .All(b => Vector3.Distance(b.pointA, v.pointA) > 0.5f /*PointNotBlocked(b, v)*/) ) .ToList(); /* foreach (BorderPoint bp in notBlocked_BP_Points ) * { * Debug.DrawRay(bp.pointA , Vector3.up, * Color.red, InfluenceCirclesManager._instance.loopWaitTime ); * }*/ if (notBlocked_BP_Points.Count == 0) { return; } //Vector3 centerOfMass = CenterOfMass_BorderPoints( borderPoints); BorderPoint closestPoint = notBlocked_BP_Points .OrderBy(v => Vector3.Distance(v.pointA, centerOfMass)).ToList()[0]; Vector3 closestPoint_Start = closestPoint.pointA; var growPoints = borderPoints.Where(v => Vector3.Distance(v.pointA, closestPoint_Start) < growDist).ToList(); #endregion //subdivide if (CheckIfNeedSubdivide(growPoints)) { growPoints = borderPoints.Where(v => Vector3.Distance(v.pointA, closestPoint_Start) < growDist).ToList(); } List <BorderPoint> growedEdges = new List <BorderPoint>(borderPoints); //GROW foreach (BorderPoint nearPoint in growPoints) { Vector3 np = nearPoint.pointA; float distToStartPoint = Vector3.Distance(np, closestPoint_Start); float towardShift = InfluenceCirclesManager.SampleGrowCurve((growDist - distToStartPoint) / growDist) * growDist; #region Normal Vector3 segmentNormal = nearPoint.normal; /* if (Vector3.Angle(segmentNormal, averageNormal) > 100) * { * segmentNormal *= -1; * } * averageNormal = Vector3.Lerp(averageNormal, segmentNormal, 0.3f);*/ #endregion //raycast against others /*towardShift*/ var lineCast_growResult = LineCastForGrow( nearPoint, towardShift, 0.2f, segmentNormal, allSceneBorderPoints, false ); towardShift = lineCast_growResult.dist; #region Connect similar fraction circles BorderPoint ibp = lineCast_growResult.intersectionBP; if (ibp != null && ibp.circle.fraction == fraction) { ConnectTwoCircles(growDist, nearPoint, ibp); break; } #endregion Vector3 newPos = nearPoint.pointA + segmentNormal * towardShift; #region raycast against self //int indexOfnearPoint = borderPoints.IndexOf(nearPoint); var intersectionBP = LineCastForGrow( nearPoint, towardShift + 0.2f, 0, segmentNormal, growedEdges, true).intersectionBP; if (intersectionBP != null) { borderPoints.Remove(nearPoint); /* Debug.DrawRay( nearPoint.pointA, Vector3.up*10, * Color.magenta, InfluenceCirclesManager._instance.loopWaitTime );*/ continue; } /* var newPosLocal = transform.InverseTransformPoint(newPos); * if ( polygon != null * && polygon.ContainsPoint( new Vector2( newPosLocal.x, newPosLocal.z ) ) ) * { * borderPoints.Remove( nearPoint ); * * /* Debug.DrawLine(nearPoint.pointA + Vector3.up*0.1f, newPos + Vector3.up * 0.1f, * Color.magenta, InfluenceCirclesManager._instance.loopWaitTime ); * Debug.DrawRay( nearPoint.pointA, Vector3.up * 10, * Color.magenta, InfluenceCirclesManager._instance.loopWaitTime );#1# * * //Debug.LogError(this); * continue; * }*/ #region AddGrowedEdges Vector3 segmentVector = (nearPoint.pointA - newPos).normalized; Vector3 newGrowedEdgeNormal = Quaternion.Euler(0, -90, 0) * segmentVector; growedEdges.Add(new BorderPoint() { pointA = nearPoint.pointA, pointB = newPos, normal = newGrowedEdgeNormal }); segmentVector = (newPos - nearPoint.pointA).normalized; newGrowedEdgeNormal = Quaternion.Euler(0, -90, 0) * segmentVector; growedEdges.Add(new BorderPoint() { pointA = newPos, pointB = nearPoint.pointA, normal = newGrowedEdgeNormal }); #endregion #endregion Debug.DrawRay(nearPoint.pointA + Vector3.up * 0.25f, segmentNormal * towardShift, Color.green, InfluenceCirclesManager._instance.loopWaitTime); nearPoint.pointA = newPos; } //GenerateTriangulation(); UpdateModel(); }
private LineCast_GrowResult LineCastForGrow(BorderPoint nearPoint, float towardShift, float shiftCorrection, Vector3 segmentNormal, List <BorderPoint> allSceneBorderPoints, bool checkNormals) { Vector3 desiredPos = nearPoint.pointA + segmentNormal * towardShift; //Vector2 instersectPoint = Vector2.zero; float vectMult = 100f; BorderPoint intersectionBP = null; foreach (var bp in allSceneBorderPoints) { if (checkNormals && bp == nearPoint || Vector3.Angle(bp.normal, nearPoint.normal) < 90) { continue; } Segment segment_1 = new Segment() { a = nearPoint.pointA.xz(), b = desiredPos.xz(), //normal = p1.normal.xz() }; Segment segment_2 = new Segment() { a = bp.pointA.xz(), b = bp.pointB.xz(), normal = bp.normal.xz() }; Vector2 intersectionPoint; if (segment_1.IntersectionWithSegmentWithAccuracy(segment_2, 0.1f, out intersectionPoint)) { float distance = Vector3.Distance(nearPoint.pointA, new Vector3(intersectionPoint.x, 0, intersectionPoint.y)); distance = Mathf.Clamp(distance - shiftCorrection, 0, float.MaxValue); towardShift = Mathf.Min(towardShift, distance); intersectionBP = bp; break; } /* if( LineIntersection( * new Vector2( nearPoint.pointA.x, nearPoint.pointA.z ) * vectMult, * new Vector2( desiredPos.x, desiredPos.z ) * vectMult, * new Vector2( bp.pointA.x, bp.pointA.z ) * vectMult, * new Vector2( bp.pointB.x, bp.pointB.z ) * vectMult, * ref instersectPoint * ) ) * { * instersectPoint /= vectMult; * float distance = Vector3.Distance(nearPoint.pointA, new Vector3(instersectPoint.x,0,instersectPoint.y) ); * //if(distance<0.01f) continue; * * distance = Mathf.Clamp( distance - shiftCorrection/*0.2f#1#, 0, float.MaxValue ); * towardShift = Mathf.Min( towardShift, distance ); * * //Debug.DrawRay( new Vector3( instersectPoint.x, 0, instersectPoint.y ), Vector3.up, Color.magenta, 10 ); * intersectionBP = bp; * break; * }*/ } return /*towardShift*/ (new LineCast_GrowResult() { dist = towardShift, intersectionBP = intersectionBP }); }
/* public float clipperScale = 1000; * public float clipperArcTolerance = 10e+3f; // 2 magnitude smaller*/ void UpdateModel() { // Update polygon model with transforms, also update calculations. _polygon = Polygon.PolygonWithSource(this); //_polygon.UpdatePointPositionsWithSource( this ); //if( offset != 0.0f ) { /* EPPZ.Geometry.Model.Polygon.clipperArcTolerance = clipperArcTolerance; * EPPZ.Geometry.Model.Polygon.clipperScale = clipperScale;*/ _offsetPolygon = _polygon.SimplifiedNotRoundedOffsetPolygon(offset); //_offsetPolygon = _polygon.SimplifiedAndRoundedOffsetPolygon( offset ); //.SimplifiedAndRoundedOffsetPolygon( offset ); } #region Border points borderPoints = new List <BorderPoint>(); //BorderPoint prevPoint = null; polygon.EnumerateEdgesRecursive(( Edge eachEdge ) => { BorderPoint newBorderPoint = new BorderPoint() { circle = this, pointA = transform.TransformPoint(new Vector3(eachEdge.a.x, 0, eachEdge.a.y)), pointB = transform.TransformPoint(new Vector3(eachEdge.b.x, 0, eachEdge.b.y)), normal = new Vector3(eachEdge.normal.x, 0, eachEdge.normal.y).normalized, //prevPoint = prevPoint }; borderPoints.Add(newBorderPoint); /* if (prevPoint != null) prevPoint.nextPoint = newBorderPoint; * prevPoint = newBorderPoint;*/ }); /* if( InfluenceCirclesManager._instance != null ) * { * float bpDebugShift = 0; * float step = 3f / (float)borderPoints.Count; * foreach( BorderPoint bp in borderPoints ) * { * Debug.DrawLine( * bp.pointA + Vector3.up * bpDebugShift, * bp.pointB + Vector3.up * bpDebugShift, * Color.red, InfluenceCirclesManager._instance.loopWaitTime ); * * bpDebugShift += step; * } * }*/ #endregion #region Setup mesh //cast points to local space /* for( var i = 0; i < polygon.points.Length; i++ ) * { * Vector3 localPoint = transform.InverseTransformPoint( new Vector3( polygon.points [ i ].x, 0, polygon.points [ i ].y) ); * polygon.points [ i ] = new Vector2( localPoint.x, localPoint.z ); * }*/ MeshFilter meshFilter = GetComponent <MeshFilter>(); meshFilter.sharedMesh = polygon.Mesh(lineColor, TriangulatorType.Dwyer); MeshRenderer meshRenderer = GetComponent <MeshRenderer>(); if (meshRenderer == null) { meshRenderer = gameObject.AddComponent <MeshRenderer>(); } if (meshRenderer != null) { if (mat != null /*&& meshRenderer.sharedMaterial ==null*/) { meshRenderer.sharedMaterial = new Material(mat); //meshRenderer./*material*/sharedMaterial.SetColor( "_FillColor", lineColor ); meshRenderer./*material*/ sharedMaterial.SetColor("_Color", lineColor); } } #endregion area = polygon.area; }
public void GrowUniform(float growDist) { #region Calc grow points SubdSegments(InfluenceCirclesManager.SegementSubdDist()); var allSceneBorderPoints = allInfluenceCircles .Where(v => v != this) .SelectMany(v => v.borderPoints).ToList(); var allSceneBorderPoints_NotThisFraction = allSceneBorderPoints .Where(c => c.circle.fraction != fraction).ToList(); var notBlocked_BP_Points = /*vertices*/ borderPoints .Where(v => allSceneBorderPoints_NotThisFraction .All(b => Vector3.Distance(b.pointA, v.pointA) > 0.25f) ) .ToList(); if (notBlocked_BP_Points.Count == 0) { return; } var growPoints = new List <BorderPoint>(/*notBlocked_BP_Points*/ notBlocked_BP_Points); List <BorderPoint> growedEdges = new List <BorderPoint>(borderPoints); #endregion borderPoints_subPolygons = new List <List <BorderPoint> >() { borderPoints }; //List<BorderPoint> connectionBorderPoints = new List<BorderPoint>(); //GROW foreach (BorderPoint nearPoint in growPoints) { Vector3 np = nearPoint.pointA; float towardShift = growDist; Vector3 segmentNormal = nearPoint.normal; //raycast against others var lineCast_growResult = LineCastForGrow( nearPoint, towardShift, 0.2f, segmentNormal, allSceneBorderPoints, false ); towardShift = lineCast_growResult.dist; #region Connect similar fraction circles BorderPoint ibp = lineCast_growResult.intersectionBP; if (ibp != null && ibp.circle.fraction == fraction) { ConnectTwoCircles(growDist, nearPoint, ibp); break; //connectionBorderPoints.Add(ibp); } #endregion Vector3 newPos = nearPoint.pointA + segmentNormal * towardShift; #region raycast against self //int indexOfnearPoint = borderPoints.IndexOf(nearPoint); var intersectionResult = LineCastForGrow( nearPoint, towardShift + 0.2f, 0, segmentNormal, growedEdges, true); if (intersectionResult.intersectionBP != null) { BorderPoint intBP = intersectionResult.intersectionBP; /* if (nearPoint.nextPoint != null) nearPoint.nextPoint.prevPoint = null; * if (nearPoint.prevPoint != null) nearPoint.prevPoint.nextPoint = null;*/ borderPoints.Remove(nearPoint); /* if( intBP.nextPoint != null ) intBP.nextPoint.prevPoint = null; * if( intBP.prevPoint != null ) intBP.prevPoint.nextPoint = null;*/ borderPoints.Remove(intBP); /* Debug.DrawLine(nearPoint.pointA + Vector3.up, nearPoint.pointB +Vector3.up, Color.red, 0.1f); * Debug.DrawLine( intersectionResult.intersectionBP.pointA + Vector3.up, * intersectionResult.intersectionBP.pointB + Vector3.up, Color.red, 0.1f );*/ continue; //newPos = nearPoint.pointA + segmentNormal * intersectionResult.dist*1.05f; } #region Is inside polygon /* var newPosLocal = transform.InverseTransformPoint(newPos); * if ( polygon != null * && polygon.ContainsPoint( new Vector2( newPosLocal.x, newPosLocal.z ) ) ) * { * borderPoints.Remove( nearPoint ); * * /* Debug.DrawLine(nearPoint.pointA + Vector3.up*0.1f, newPos + Vector3.up * 0.1f, * Color.magenta, InfluenceCirclesManager._instance.loopWaitTime ); * Debug.DrawRay( nearPoint.pointA, Vector3.up * 10, * Color.magenta, InfluenceCirclesManager._instance.loopWaitTime );#1# * * //Debug.LogError(this); * continue; * }*/ #endregion #region AddGrowedEdges Vector3 segmentVector = (nearPoint.pointA - newPos).normalized; Vector3 newGrowedEdgeNormal = Quaternion.Euler(0, -90, 0) * segmentVector; growedEdges.Add(new BorderPoint() { pointA = nearPoint.pointA, pointB = newPos, normal = newGrowedEdgeNormal }); segmentVector = (newPos - nearPoint.pointA).normalized; newGrowedEdgeNormal = Quaternion.Euler(0, -90, 0) * segmentVector; growedEdges.Add(new BorderPoint() { pointA = newPos, pointB = nearPoint.pointA, normal = newGrowedEdgeNormal }); #endregion #endregion /* Debug.DrawRay( nearPoint.pointA + Vector3.up * 0.25f, segmentNormal * towardShift, * Color.green, InfluenceCirclesManager._instance.loopWaitTime );*/ nearPoint.pointA = newPos; } //GenerateTriangulation(); UpdateModel(); }