public override Vector3 mapPointToPath(Vector3 point, ref mapReturnStruct tStruct)
{
float d;
float minDistance = float.MaxValue;// FLT_MAX;
Vector3 onPath = Vector3.zero;
// loop over all segments, find the one nearest to the given point
for (int i = 1; i < pointCount; i++)
{
segmentLength = lengths[i];
segmentNormal = normals[i];
d = pointToSegmentDistance(point, points[i - 1], points[i]);
if (d < minDistance)
{
minDistance = d;
onPath = chosen;
tStruct.tangent = segmentNormal;
}
}
// measure how far original point is outside the Pathway's "tube"
tStruct.outside = (onPath - point).magnitude - radius;
// return point on path
return(onPath);
}
public bool isInsidePath(Vector3 point)
{
mapReturnStruct mapReturnStruct = default(mapReturnStruct);
this.mapPointToPath(point, ref mapReturnStruct);
return(mapReturnStruct.outside < 0f);
}
public float howFarOutsidePath(Vector3 point)
{
mapReturnStruct mapReturnStruct = default(mapReturnStruct);
this.mapPointToPath(point, ref mapReturnStruct);
return(mapReturnStruct.outside);
}
// ----------------------------------------------------------------------------
// Path Following behaviors
public Vector3 steerToStayOnPath(float predictionTime, Pathway path)
{
// predict our future position
Vector3 futurePosition = predictFuturePosition(predictionTime);
// find the point on the path nearest the predicted future position
mapReturnStruct tStruct = new mapReturnStruct();
Vector3 onPath = path.mapPointToPath(futurePosition, ref tStruct);
if (tStruct.outside < 0)
{
// our predicted future position was in the path,
// return zero steering.
return(Vector3.zero);
}
else
{
// our predicted future position was outside the path, need to
// steer towards it. Use onPath projection of futurePosition
// as seek target
#if ANNOTATE_PATH
annotatePathFollowing(futurePosition, onPath, onPath, tStruct.outside);
#endif
return(steerForSeek(onPath));
}
}
// how far outside path tube is the given point? (negative is inside)
public float howFarOutsidePath(Vector3 point)
{
//float outside;
//Vector3 tangent;
mapReturnStruct tStruct = new mapReturnStruct();
mapPointToPath(point, ref tStruct);
return(tStruct.outside);
}
public Vector3 steerToStayOnPath(float predictionTime, Pathway path)
{
Vector3 vector = this.predictFuturePosition(predictionTime);
mapReturnStruct mapReturnStruct = default(mapReturnStruct);
Vector3 vector2 = path.mapPointToPath(vector, ref mapReturnStruct);
if (mapReturnStruct.outside < 0f)
{
return(Vector3.get_zero());
}
this.annotatePathFollowing(vector, vector2, vector2, mapReturnStruct.outside);
return(this.steerForSeek(vector2));
}
public override Vector3 mapPointToPath(Vector3 point, ref mapReturnStruct tStruct)
{
float num = 3.40282347E+38f;
Vector3 zero = Vector3.get_zero();
for (int i = 1; i < this.pointCount; i++)
{
this.segmentLength = this.lengths[i];
this.segmentNormal = this.normals[i];
float num2 = this.pointToSegmentDistance(point, this.points[i - 1], this.points[i]);
if (num2 < num)
{
num = num2;
zero = this.chosen;
tStruct.tangent = this.segmentNormal;
}
}
tStruct.outside = (zero - point).get_magnitude() - this.radius;
return(zero);
}
public virtual Vector3 mapPointToPath(Vector3 point, ref mapReturnStruct tStruct)
{
return(Vector3.get_zero());
}
public override Vector3 mapPointToPath(Vector3 point, ref mapReturnStruct tStruct)
{
float d;
float minDistance = float.MaxValue;// FLT_MAX;
Vector3 onPath=Vector3.zero;
// loop over all segments, find the one nearest to the given point
for (int i = 1; i < pointCount; i++)
{
segmentLength = lengths[i];
segmentNormal = normals[i];
d = pointToSegmentDistance (point, points[i-1], points[i]);
if (d < minDistance)
{
minDistance = d;
onPath = chosen;
tStruct.tangent = segmentNormal;
}
}
// measure how far original point is outside the Pathway's "tube"
tStruct.outside = (onPath - point).magnitude - radius;
// return point on path
return onPath;
}
// Given an arbitrary point ("A"), returns the nearest point ("P") on
// this path. Also returns, via output arguments, the path tangent at
// P and a measure of how far A is outside the Pathway's "tube". Note
// that a negative distance indicates A is inside the Pathway.
public virtual Vector3 mapPointToPath(Vector3 point, ref mapReturnStruct tStruct)
{
return Vector3.zero;
}
// is the given point inside the path tube?
public bool isInsidePath(Vector3 point)
{
//float outside;
//Vector3 tangent;
mapReturnStruct tStruct = new mapReturnStruct();
mapPointToPath(point, ref tStruct);
return tStruct.outside < 0;
}
/// <summary>
/// Should the force be calculated?
/// </summary>
/// <returns>
/// A <see cref="Vector3"/>
/// </returns>
protected override Vector3 CalculateForce()
{
if (_path == null)
return Vector3.zero;
// our goal will be offset from our path distance by this amount
float pathDistanceOffset = (int)_direction * _predictionTime * Vehicle.Speed;
// predict our future position
Vector3 futurePosition = Vehicle.PredictFuturePosition(_predictionTime);
// measure distance along path of our current and predicted positions
float nowPathDistance = _path.mapPointToPathDistance (Vehicle.Position);
float futurePathDistance = _path.mapPointToPathDistance (futurePosition);
// are we facing in the correction direction?
bool rightway = ((pathDistanceOffset > 0) ? (nowPathDistance < futurePathDistance) : (nowPathDistance > futurePathDistance));
// find the point on the path nearest the predicted future position
// XXX need to improve calling sequence, maybe change to return a
// XXX special path-defined object which includes two Vector3s and a
// XXX bool (onPath,tangent (ignored), withinPath)
mapReturnStruct tStruct = new mapReturnStruct ();
_path.mapPointToPath (futurePosition, ref tStruct);
// no steering is required if (a) our future position is inside
// the path tube and (b) we are facing in the correct direction
if ((tStruct.outside < 0) && rightway) {
// all is well, return zero steering
return Vector3.zero;
} else {
// otherwise we need to steer towards a target point obtained
// by adding pathDistanceOffset to our current path position
float targetPathDistance = nowPathDistance + pathDistanceOffset;
Vector3 target = _path.mapPathDistanceToPoint (targetPathDistance);
// return steering to seek target on path
return Vehicle.GetSeekVector(target);
}
}
// ----------------------------------------------------------------------------
// Path Following behaviors
public Vector3 steerToStayOnPath(float predictionTime, Pathway path)
{
// predict our future position
Vector3 futurePosition = predictFuturePosition (predictionTime);
// find the point on the path nearest the predicted future position
mapReturnStruct tStruct = new mapReturnStruct();
Vector3 onPath = path.mapPointToPath(futurePosition, ref tStruct);
if (tStruct.outside < 0)
{
// our predicted future position was in the path,
// return zero steering.
return Vector3.zero;
}
else
{
// our predicted future position was outside the path, need to
// steer towards it. Use onPath projection of futurePosition
// as seek target
#if ANNOTATE_PATH
annotatePathFollowing (futurePosition, onPath, onPath,tStruct.outside);
#endif
return steerForSeek (onPath);
}
}
public Vector3 steerToFollowPath(int direction, float predictionTime, Pathway path)
{
// our goal will be offset from our path distance by this amount
float pathDistanceOffset = direction * predictionTime * Speed;
// predict our future position
Vector3 futurePosition = predictFuturePosition (predictionTime);
// measure distance along path of our current and predicted positions
float nowPathDistance =
path.mapPointToPathDistance (Position);
float futurePathDistance =
path.mapPointToPathDistance (futurePosition);
// are we facing in the correction direction?
bool rightway = ((pathDistanceOffset > 0) ?
(nowPathDistance < futurePathDistance) :
(nowPathDistance > futurePathDistance));
// find the point on the path nearest the predicted future position
// XXX need to improve calling sequence, maybe change to return a
// XXX special path-defined object which includes two Vector3s and a
// XXX bool (onPath,tangent (ignored), withinPath)
mapReturnStruct tStruct = new mapReturnStruct();
Vector3 onPath = path.mapPointToPath(futurePosition, ref tStruct);
// no steering is required if (a) our future position is inside
// the path tube and (b) we are facing in the correct direction
if ((tStruct.outside < 0) && rightway)
{
// all is well, return zero steering
return Vector3.zero;
}
else
{
// otherwise we need to steer towards a target point obtained
// by adding pathDistanceOffset to our current path position
float targetPathDistance = nowPathDistance + pathDistanceOffset;
Vector3 target = path.mapPathDistanceToPoint (targetPathDistance);
#if ANNOTATE_PATH
annotatePathFollowing(futurePosition, onPath, target, tStruct.outside);
//Debug.DrawLine(Position, path.LastPoint, Color.green);
#endif
// return steering to seek target on path
return steerForSeek (target);
}
}