public List <Waypoint> GenerateWaypointsBetweenTwoPoints(Navmesh navmesh, Vector3 startPos, Vector3 endPos)
{
List <Waypoint> waypoints = new List <Waypoint>();
NavmeshQuery query;
var status = NavmeshQuery.Create(navmesh, 1024, out query);
if (!NavUtil.Failed(status))
{
org.critterai.Vector3 navStartPointVect;
org.critterai.Vector3 navEndPointVect;
var navStartPointStatus = query.GetNearestPoint(1, new org.critterai.Vector3(startPos.x, startPos.y, startPos.z), out navStartPointVect);
var navEndPointStatus = query.GetNearestPoint(1, new org.critterai.Vector3(startPos.x, startPos.y, startPos.z), out navEndPointVect);
if (navStartPointStatus == NavStatus.Sucess && navEndPointStatus == NavStatus.Sucess)
{
NavmeshPoint navStartPoint = new NavmeshPoint(1, new org.critterai.Vector3(startPos.x, startPos.y, startPos.z));
NavmeshPoint navEndPoint = new NavmeshPoint(1, new org.critterai.Vector3(endPos.x, endPos.y, endPos.z));
uint[] path = new uint[1024];
int pathCount;
status = query.FindPath(navStartPoint, navEndPoint, new NavmeshQueryFilter(), path, out pathCount);
if (!NavUtil.Failed(status))
{
const int MaxStraightPath = 4;
int wpCount;
org.critterai.Vector3[] wpPoints = new org.critterai.Vector3[MaxStraightPath];
uint[] wpPath = new uint[MaxStraightPath];
WaypointFlag[] wpFlags = new WaypointFlag[MaxStraightPath];
status = query.GetStraightPath(navStartPoint.point, navEndPoint.point
, path, 0, pathCount, wpPoints, wpFlags, wpPath
, out wpCount);
if (!NavUtil.Failed(status) && wpCount > 0)
{
foreach (var wp in wpPoints)
{
Mogre.Vector3 wayPointPos = new Vector3(wp.x, wp.y, wp.z);
waypoints.Add(new Waypoint(wayPointPos, new Vector3()));
}
}
}
}
}
return(waypoints);
}
/// <summary>
/// Returns the staight path from the start to the end point within the polygon corridor.
/// </summary>
/// <remarks>
/// <para>
/// This method peforms what is often called 'string pulling'.
/// </para>
/// <para>
/// If the provided result buffers are too small for the entire result, they will
/// be filled as far as possible from the start point toward the end point.
/// </para>
/// <para>
/// The start point is clamped to the first polygon in the path, and the end point
/// is clamped to the last. So the start and end points should be within or very near the
/// first and last polygons respectively. The pathStart and pathCount parameters can be
/// adjusted to restrict the usable portion of the the path to meet this requirement.
/// (See the example below.)
/// </para>
/// <para>
/// The returned polygon references represent the polygon that is entered at the
/// associated path point. The reference associated with the end point will always be
/// zero.
/// </para>
/// <para>
/// Example use case for adjusting the straight path during locomotion:
/// </para>
/// <para>
/// Senario: The path consists of polygons A, B, C, D, with the start point in A and
/// the end point in D.
/// </para>
/// <para>
/// The first call to the method will return straight waypoints for the entire path:
/// </para>
/// <code>
/// query.GetStraightPath(startPoint, endPoint
/// , path
/// , 0, 4 // pathStart, pathCount
/// , straigthPath, null, null
/// , out straightCount);
/// </code>
/// <para>
/// If the agent moves into polygon B and needs to recaclulate its straight path for
/// some reason, it can call the method as follows using the original path buffer:
/// </para>
/// <code>
/// query.GetStraightPath(startPoint, endPoint
/// , path
/// , 1, 3 // pathStart, pathCount <- Note the changes here.
/// , straigthPath, null, null
/// , out straightCount);
/// </code>
/// </remarks>
/// <param name="start">The start point.</param>
/// <param name="end">The end point.</param>
/// <param name="path">
/// The list of polygon references that represent the path corridor.
/// </param>
/// <param name="pathStart">
/// The index within the path buffer of the polygon that contains the start point.
/// </param>
/// <param name="pathCount">
/// The length of the path within the path buffer. (endPolyIndex - startPolyIndex)
/// </param>
/// <param name="resultPoints">
/// Points describing the straight path. [(point) * straightPathCount].</param>
/// <param name="resultFlags">
/// Flags describing each point. [(flags) * striaghtPathCount] (Optional)</param>
/// <param name="resultRefs">
/// The reference of the polygon that is being entered at the point position.
/// [(polyRef) * straightPathCount] (Optional)</param>
/// <param name="resultCount">The number of points in the straight path.</param>
/// <returns>The <see cref="NavStatus" /> flags for the query.</returns>
public NavStatus GetStraightPath(Vector3 start, Vector3 end
, uint[] path, int pathStart, int pathCount
, Vector3[] resultPoints, WaypointFlag[] resultFlags, uint[] resultRefs
, out int resultCount)
{
resultCount = 0;
int maxPath = resultPoints.Length;
maxPath = (resultFlags == null ? maxPath
: Math.Min(resultFlags.Length, maxPath));
maxPath = (resultRefs == null ? maxPath
: Math.Min(resultRefs.Length, maxPath));
if (maxPath < 1)
return (NavStatus.Failure | NavStatus.InvalidParam);
return NavmeshQueryEx.dtqFindStraightPath(root
, ref start
, ref end
, path
, pathStart
, pathCount
, resultPoints
, resultFlags
, resultRefs
, ref resultCount
, maxPath);
}
public Waypoint(string name, WaypointFlag flag)
{
Name = name;
Flag = flag;
}
