| public static Subdivide ( Vector3 path, int subdivisions ) : Vector3[] | ||
| path | Vector3 | |
| subdivisions | int | |
| return | Vector3[] | |
public override void Apply (Path p) {
if (!useRaycasting && !useGraphRaycasting) return;
var points = p.vectorPath;
if (ValidateLine(null, null, p.vectorPath[0], p.vectorPath[p.vectorPath.Count-1])) {
// A very common case is that there is a straight line to the target.
var s = p.vectorPath[0];
var e = p.vectorPath[p.vectorPath.Count-1];
points.ClearFast();
points.Add(s);
points.Add(e);
} else {
int iterations = iterationsByQuality[(int)quality];
for (int it = 0; it < iterations; it++) {
if (it != 0) {
Polygon.Subdivide(points, buffer, 3);
Memory.Swap(ref buffer, ref points);
buffer.ClearFast();
points.Reverse();
}
points = quality >= Quality.High ? ApplyDP(p, points) : ApplyGreedy(p, points);
}
if ((iterations % 2) == 0) points.Reverse();
}
p.vectorPath = points;
}
public override void Apply(Path p)
{
if (!useRaycasting && !useGraphRaycasting)
{
return;
}
var points = p.vectorPath;
cachedFilter.path = p;
// Use the same graph mask as the path.
// We don't want to use the tag mask or other options for this though since then the linecasting will be will confused.
cachedNNConstraint.graphMask = p.nnConstraint.graphMask;
if (ValidateLine(null, null, p.vectorPath[0], p.vectorPath[p.vectorPath.Count - 1], cachedFilter.cachedDelegate, cachedNNConstraint))
{
// A very common case is that there is a straight line to the target.
var s = p.vectorPath[0];
var e = p.vectorPath[p.vectorPath.Count - 1];
points.ClearFast();
points.Add(s);
points.Add(e);
}
else
{
int iterations = iterationsByQuality[(int)quality];
for (int it = 0; it < iterations; it++)
{
if (it != 0)
{
Polygon.Subdivide(points, buffer, 3);
Memory.Swap(ref buffer, ref points);
buffer.ClearFast();
points.Reverse();
}
points = quality >= Quality.High ? ApplyDP(p, points, cachedFilter.cachedDelegate, cachedNNConstraint) : ApplyGreedy(p, points, cachedFilter.cachedDelegate, cachedNNConstraint);
}
if ((iterations % 2) == 0)
{
points.Reverse();
}
}
p.vectorPath = points;
}
// Token: 0x060026B8 RID: 9912 RVA: 0x001AC284 File Offset: 0x001AA484
public override void Apply(Path p)
{
if (!this.useRaycasting && !this.useGraphRaycasting)
{
return;
}
List <Vector3> list = p.vectorPath;
if (this.ValidateLine(null, null, p.vectorPath[0], p.vectorPath[p.vectorPath.Count - 1]))
{
Vector3 item = p.vectorPath[0];
Vector3 item2 = p.vectorPath[p.vectorPath.Count - 1];
list.ClearFast <Vector3>();
list.Add(item);
list.Add(item2);
}
else
{
int num = RaycastModifier.iterationsByQuality[(int)this.quality];
for (int i = 0; i < num; i++)
{
if (i != 0)
{
Polygon.Subdivide(list, RaycastModifier.buffer, 3);
Memory.Swap <List <Vector3> >(ref RaycastModifier.buffer, ref list);
RaycastModifier.buffer.ClearFast <Vector3>();
list.Reverse();
}
list = ((this.quality >= RaycastModifier.Quality.High) ? this.ApplyDP(p, list) : this.ApplyGreedy(p, list));
}
if (num % 2 == 0)
{
list.Reverse();
}
}
p.vectorPath = list;
}
public List <Vector3> SmoothSimple(List <Vector3> path)
{
if (path.Count < 2)
{
return(path);
}
List <Vector3> subdivided;
if (uniformLength)
{
// Clamp to a small value to avoid the path being divided into a huge number of segments
maxSegmentLength = Mathf.Max(maxSegmentLength, 0.005f);
float pathLength = 0;
for (int i = 0; i < path.Count - 1; i++)
{
pathLength += Vector3.Distance(path[i], path[i + 1]);
}
int estimatedNumberOfSegments = Mathf.FloorToInt(pathLength / maxSegmentLength);
// Get a list with an initial capacity high enough so that we can add all points
subdivided = ListPool <Vector3> .Claim(estimatedNumberOfSegments + 2);
float distanceAlong = 0;
// Sample points every [maxSegmentLength] world units along the path
for (int i = 0; i < path.Count - 1; i++)
{
var start = path[i];
var end = path[i + 1];
float length = Vector3.Distance(start, end);
while (distanceAlong < length)
{
subdivided.Add(Vector3.Lerp(start, end, distanceAlong / length));
distanceAlong += maxSegmentLength;
}
distanceAlong -= length;
}
// Make sure we get the exact position of the last point
subdivided.Add(path[path.Count - 1]);
}
else
{
subdivisions = Mathf.Max(subdivisions, 0);
if (subdivisions > 10)
{
Debug.LogWarning("Very large number of subdivisions. Cowardly refusing to subdivide every segment into more than " + (1 << subdivisions) + " subsegments");
subdivisions = 10;
}
int steps = 1 << subdivisions;
subdivided = ListPool <Vector3> .Claim((path.Count - 1) *steps + 1);
Polygon.Subdivide(path, subdivided, steps);
}
if (strength > 0)
{
for (int it = 0; it < iterations; it++)
{
Vector3 prev = subdivided[0];
for (int i = 1; i < subdivided.Count - 1; i++)
{
Vector3 tmp = subdivided[i];
// prev is at this point set to the value that subdivided[i-1] had before this loop started
// Move the point closer to the average of the adjacent points
subdivided[i] = Vector3.Lerp(tmp, (prev + subdivided[i + 1]) / 2F, strength);
prev = tmp;
}
}
}
return(subdivided);
}
// Token: 0x060026C3 RID: 9923 RVA: 0x001ACF04 File Offset: 0x001AB104
public List <Vector3> SmoothSimple(List <Vector3> path)
{
if (path.Count < 2)
{
return(path);
}
List <Vector3> list;
if (this.uniformLength)
{
this.maxSegmentLength = Mathf.Max(this.maxSegmentLength, 0.005f);
float num = 0f;
for (int i = 0; i < path.Count - 1; i++)
{
num += Vector3.Distance(path[i], path[i + 1]);
}
list = ListPool <Vector3> .Claim(Mathf.FloorToInt(num / this.maxSegmentLength) + 2);
float num2 = 0f;
for (int j = 0; j < path.Count - 1; j++)
{
Vector3 a = path[j];
Vector3 b = path[j + 1];
float num3 = Vector3.Distance(a, b);
while (num2 < num3)
{
list.Add(Vector3.Lerp(a, b, num2 / num3));
num2 += this.maxSegmentLength;
}
num2 -= num3;
}
list.Add(path[path.Count - 1]);
}
else
{
this.subdivisions = Mathf.Max(this.subdivisions, 0);
if (this.subdivisions > 10)
{
Debug.LogWarning("Very large number of subdivisions. Cowardly refusing to subdivide every segment into more than " + (1 << this.subdivisions) + " subsegments");
this.subdivisions = 10;
}
int num4 = 1 << this.subdivisions;
list = ListPool <Vector3> .Claim((path.Count - 1) *num4 + 1);
Polygon.Subdivide(path, list, num4);
}
if (this.strength > 0f)
{
for (int k = 0; k < this.iterations; k++)
{
Vector3 a2 = list[0];
for (int l = 1; l < list.Count - 1; l++)
{
Vector3 vector = list[l];
list[l] = Vector3.Lerp(vector, (a2 + list[l + 1]) / 2f, this.strength);
a2 = vector;
}
}
}
return(list);
}
