Esempio n. 1
0
        public override Vector3 mapPointToPath(Vector3 point, mapReturnStruct tStruct)//Vector3 tangent, float outside)
        {
            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).Length - radius;//Vector3::distance (onPath, point) - radius;

            // return point on path
            return(onPath);
        }
Esempio n. 2
0
        // ----------------------------------------------------------------------------
        // 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
            //Vector3 tangent;
            //float outside;

            mapReturnStruct tStruct = new mapReturnStruct();

            Vector3 onPath = path.mapPointToPath(futurePosition, 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
                annotatePathFollowing(futurePosition, onPath, onPath, tStruct.outside);
                return(steerForSeek(onPath));
            }
        }
Esempio n. 3
0
        // 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, tStruct);//tangent, outside);
            return(tStruct.outside);
        }
Esempio n. 4
0
        // is the given point inside the path tube?
        public bool isInsidePath(Vector3 point)
        {
            //float outside;
            //Vector3 tangent;
            mapReturnStruct tStruct = new mapReturnStruct();

            mapPointToPath(point, tStruct);//tangent, outside);
            return tStruct.outside < 0;
        }
Esempio n. 5
0
        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)
            // Vector3 tangent;
            //float outside;
            mapReturnStruct tStruct = new mapReturnStruct();
            Vector3         onPath  = path.mapPointToPath(futurePosition, 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);

                annotatePathFollowing(futurePosition, onPath, target, tStruct.outside);

                // return steering to seek target on path
                return(steerForSeek(target));
            }
        }
Esempio n. 6
0
 // 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, mapReturnStruct tStruct)
 {
     return(Vector3.ZERO);
 }
Esempio n. 7
0
 // 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, mapReturnStruct tStruct)
 {
     return Vector3.ZERO;
 }
Esempio n. 8
0
        //Vector3 tangent, float outside)
        public override Vector3 mapPointToPath(Vector3 point, 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).Length - radius;//Vector3::distance (onPath, point) - radius;

            // return point on path
            return onPath;
        }
Esempio n. 9
0
        // ----------------------------------------------------------------------------
        // 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
            //Vector3 tangent;
            //float outside;

            mapReturnStruct tStruct = new mapReturnStruct();

            Vector3 onPath = path.mapPointToPath(futurePosition, 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
                annotatePathFollowing (futurePosition, onPath, onPath,tStruct.outside);
                return steerForSeek (onPath);
            }
        }
Esempio n. 10
0
        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)
               // Vector3 tangent;
            //float outside;
             mapReturnStruct tStruct = new mapReturnStruct();
             Vector3 onPath = path.mapPointToPath(futurePosition, 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);

                annotatePathFollowing(futurePosition, onPath, target, tStruct.outside);

                // return steering to seek target on path
                return steerForSeek (target);
            }
        }