Walkabout Navigation Toolkit help thread

#1 A note:

If you're adding this to an AFX project, pay attention to AiPlayer.cpp/.h. AFX adds a couple of methods to the AIPlayer class and these aren't included in the Walkabout source (naturally). So, either use a merge tool or back up your AFX AiPlayer files, copy the new ones, then copy the saveMoveState() and restartMove() method code manually - not hard either way.

Thanks again to Daniel Buckmaster and Jeff Faust for their awesome kits!

(Should specify - T3D 1.2 commercial)

#2 Oops - ran into a crash in phase 3 of mission loading for the walkabout basic demo level - looking into it....

#3 Hrm, so it sounds like the server-side loads up fine or you'd have a crash earlier than that, no?

#4 I'm thinking that I probably have something else somewhere that seems ok, but is different in AFX - I copied your files over the AFX files so I might have stomped something important that compiles but does not play well with Jeff's changes. I'll track it down and report my findings sometime in the coming week.

Maybe I'll start over (only had put about an hour of work into it) and watch what I'm doing more carefully. It'd probably be easier to figure out what I did that way anyhow.

#5 Yeah, doing a WInMerge of the entire source directory is probably the best way to handle this. If there are merge conflicts, well, that's an obvious problem, but if not we'll have to look at the details of the crash more carefully.

#6 hmmm I seem to have it almost working in an afx-hybrid project. I'm using Acaster's version of aiPlayer but get errors whenever my scripts do something like this:

function AIPlayer::moveToNode(%this,%index)
{
   // Move to the given path node index
   %this.currentNode = %index;
   %node = %this.path.getObject(%index);
...

I get errors from the getObject:

scripts/server/aiPlayer.cs (302): Unknown command getObject.

I get similar errors from %path.getCount as well.

...do I need to re-write the path functions? How do I access individual nodes?

#7 In the Recast Resource, I wrote NavPath to have the same interface as SimPath, despite the fact that SimPath is actually a type of SimGroup that contains objects for each waypoint. I did this so that people could easily plug the resource into existing path-following scripts.

Walkabout, however, takes care of path following automatically, so I removed the getObject/getPosition interface that was mimicking SimPath*. Now, instead of using AIPlayer::followPath, you can use AIPlayer::setPathDestination, which is defined in aiPlayer.cpp.

If you still need to acces individual nodes in a NavPath, you can use the getNode method, which takes an index and returns a position. Oh, and the size() method returns the number of nodes in the path.

*I would have done this anyway, since a NavPath is not a SimPath, and it was silly for me to try and make it into one.

#8 @Dan:

Thanks! It's all working now...

FWIW here's the traditional scripts modded for Walkabout:

function AIPlayer::followPath(%this,%path,%node)
{
   
   // Start the player following a path
   %this.stopThread(0);
   if (!isObject(%path))
   {
      %this.path = "";
      return;
   }

   if (%node > %path.size() - 1)
      %this.targetNode = %path.size() - 1;
   else
      %this.targetNode = %node;

   if (%this.path $= %path)
      %this.moveToNode(%this.currentNode);
   else
   {
      %this.path = %path;
      %this.moveToNode(0);
   }
}

function AIPlayer::moveToNextNode(%this)
{
   if (%this.targetNode < 0 || %this.currentNode < %this.targetNode)
   {
      if (%this.currentNode < %this.path.size() - 1)
         %this.moveToNode(%this.currentNode + 1);
      else
         %this.moveToNode(0);
   }
   else
      if (%this.currentNode == 0)
         %this.moveToNode(%this.path.size() - 1);
      else
         %this.moveToNode(%this.currentNode - 1);
}

function AIPlayer::moveToNode(%this,%index)
{
   // Move to the given path node index
   %this.currentNode = %index;
   %xfm = %this.path.getNode(%index);
   %this.setMoveDestination(%xfm, %index == %this.targetNode);
}

EDIT:

Or:

function AIPlayer::moveToNode(%this,%index)
{
   // Move to the given path node index
   %this.currentNode = %index;
   %xfm = %this.path.getNode(%index);
   //%this.setMoveDestination(%xfm, %index == %this.targetNode);
   %this.setPathDestination(%xfm);
}

#9 Nice. I was getting a crash because of spawning using the DefaultPlayerData from AFX - which has no mesh file defined ... and spawning a Player instead of an AiPlayer.... Think I've got my head out of my rear-end now.

#10 "which has no mesh file defined ... and spawning a Player instead of an AiPlayer"

no mesh file!

something like this:
datablock PlayerData(UniquePlayer) { };
?

#11 That would do it. In the AFX version of datablocks/player.cs the shapeFile field is commented out.

#12 I have the systems working together nicely but realized that I should probably have merged the editor scripts as well. Dropping the tools into the AFX project caused a reversion to the T3D Camera instead of the afxCamera in the AFX tool scripts so I started getting script errors related to camera.getPosition() and such.

Upon investigation I discovered that afxCamera does not derive from Camera but directly from GameBase (just like Camera). I started work on unifying the interfaces of the two camera classes by creating new methods for afxCamera and then, after about four hours of wrenching on that I realized that it would probably have been faster to reparent afxCamera to Camera and add the engine methods needed for afxCamera. So I've re-embarqued (rebarqued?) on the path to getting these two camera classes to share their primary interface while leaving the cool afxCamera bits intact. When I get these working satisfactorily I'll pass them back to Jeff and Daniel for inspection (and probably clean-up - I have a bad habit of leaving "working code" in place even when it's no longer called).

#13 Huh, the Walkabout editor scripts shouldn't touch any other editor modes. If they do, that's a big problem. I'm very unfamiliar with AFX, but if I understand, basically AFX provides a new editor camera in all modes, but when you added the Walkabout editor scripts, the AFX camera was no longer used in any editor modes?

#14 I'll have to double check - I just noticed the camera error messages after getting it up and running because I was actually paying attention then. Those errors might have been occurring all along and I just didn't catch them. I don't think the editor creates a new camera for each mode, though I haven't looked. I started the game and then switched to the editor via F11, so I'm sure it just used the current camera and started complaining that getRotation() etc were unknown commands.

However, I think it would be nice to be able to treat an afxCamera as if it were an ordinary one and have it behave accordingly while keeping the cool stuff that Jeff added. I'll keep you posted and let you and Jeff have a peek when it's functioning. Really more for Jeff, I suppose - but it would help to prevent this sort of thing.

Walkabout works great in AFX, by the way - just had to fiddle with tile count, polys and whatnot to get the mesh resolution and size I wanted and off it went.

#15 Ok, to sum up -

Use WinMerge to carefully merge Walkabout into AFX.

In afx/afxCamera.h, reparent afxCameraData and afxCamera to CameraData and Camera respectively.

Within each of those, change the typedef for Parent to the new parent class.

Next, add the following code somewhere (I added an afxCamera_scriptBinding.h file to the DLL project's Source Files/source folder):

//=============================================================================
//    Console API.
//=============================================================================
// MARK: ---- Console API ----

//-----------------------------------------------------------------------------
#include "console/engineAPI.h"
#include "console/consoleTypes.h"

#include "afx/afxCamera.h"

DefineEngineMethod( afxCamera, getRotation, Point3F, (), ,
                   "Get the afxCamera's Euler rotation in radians.\n\n"
                   "@returns The rotation in radians in the form of \"x y z\".")
{
   return object->getRotation();
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setRotation, void, ( Point3F rot ), ,
                   "Set the afxCamera's Euler rotation in radians.\n\n"
                   "@param rot The rotation in radians in the form of \"x y z\"."
                   "@note Rotation around the Y axis is ignored" )
{
   return object->setRotation( rot );
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, getOffset, Point3F, (), ,
                   "Get the afxCamera's offset from its orbit or tracking point.\n\n"
                   "The offset is added to the afxCamera's position when set to afxCameraMode::OrbitObject.\n"
                   "@returns The offset in the form of \"x y z\".")
{
   return object->getOffset();
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setOffset, void, (Point3F offset), ,
                   "Set the afxCamera's offset.\n\n"
                   "The offset is added to the afxCamera's position when set to afxCameraMode::OrbitObject.\n"
                   "@param offset The distance to offset the afxCamera by in the form of \"x y z\".")
{
   object->setOffset(offset);
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setOrbitObject, bool, (GameBase* orbitObject, AngAxisF rotation, F32 minDistance, 
                    F32 maxDistance, F32 initDistance, bool ownClientObject),
                    (false, 10.0f, false),
                    "Set the afxCamera to orbit around a given object.\n\n"
                    "@param orbitObject The object to orbit around.\n"
                    "@param rotation The initial afxCamera rotation about the object in radians in the form of \"x y z\".\n"
                    "@param minDistance The minimum distance allowed to the orbit object or point.\n"
                    "@param maxDistance The maximum distance allowed from the orbit object or point.\n"
                    "@param initDistance The initial distance from the orbit object or point.\n"
                    "@param ownClientObject [optional] Are we orbiting an object that is owned by us?  Default is false.\n"
                    "@param offset [optional] An offset added to the afxCamera's position.  Default is no offset.\n"
                    "@param locked [optional] Indicates the afxCamera does not receive input from the player.  Default is false.\n"
                    "@returns false if the given object could not be found.\n"
                    "@see afxCamera::setOrbitMode()\n")
{
   if( !orbitObject )
   {
      Con::errorf( "afxCamera::setOrbitObject - Invalid object");
      return false;
   }
   Point3F aimPoint = Point3F(0.0f, 0.0f, 0.0f);
   object->setOrbitMode(orbitObject, aimPoint, rotation, minDistance, maxDistance, initDistance, ownClientObject);
   return true;
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setOrbitPoint, void, (Point3F orbitPoint, AngAxisF rotation, F32 minDistance, 
                    F32 maxDistance, F32 initDistance, bool ownClientObject),
                    (false, 10.0f, false),
                    "Set the afxCamera to orbit around a given point.\n\n"
                    "@param orbitPoint The point to orbit around.  In the form of \"x y z ax ay az aa\" such as returned by SceneObject::getTransform().\n"
                    "@param minDistance The minimum distance allowed to the orbit object or point.\n"
                    "@param maxDistance The maximum distance allowed from the orbit object or point.\n"
                    "@param initDistance The initial distance from the orbit object or point.\n"
                    "@param offset [optional] An offset added to the afxCamera's position.  Default is no offset.\n"
                    "@param locked [optional] Indicates the afxCamera does not receive input from the player.  Default is false.\n"
                    "@see afxCamera::setOrbitMode()\n")
{
   object->setOrbitMode(NULL, orbitPoint, rotation, minDistance, maxDistance, initDistance, ownClientObject);

}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setTrackObject, bool, (GameBase* trackObject, Point3F offset), (Point3F(0.0f, 0.0f, 0.0f)),
                    "Set the afxCamera to track a given object.\n\n"
                    "@param trackObject The object to track.\n"
                    "@param offset [optional] An offset added to the afxCamera's position.  Default is no offset.\n"
                    "@returns false if the given object could not be found.\n")
{
   if(!trackObject)
   {
      Con::warnf("Cannot track non-existing object.");
      return false;
   }

   object->setTrackObject(trackObject, offset);
   return true;
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setNewtonFlyMode, void, (), ,
                    "Set the afxCamera to fly freely, but with ease-in and ease-out.\n\n"
                    "This method allows for the same 6 degrees of freedom as afxCamera::setFlyMode() but "
                    "activates the ease-in and ease-out on the afxCamera's movement.  To also activate "
                    "Newton mode for the afxCamera's rotation, set afxCamera::newtonRotation to true.")
{
   object->setNewtonFlyMode();
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, isRotationDamped, bool, (), ,
                    "Is this a Newton Fly mode afxCamera with damped rotation?\n\n"
                    "@returns true if the afxCamera uses a damped rotation.  i.e. afxCamera::newtonRotation is set to true.\n")
{
   return object->isRotationDamped();
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, getAngularVelocity, VectorF, (), ,
                   "Get the angular velocity for a Newton mode afxCamera.\n\n"
                   "@returns The angular velocity in the form of \"x y z\".\n"
                   "@note Only returns useful results when afxCamera::newtonRotation is set to true.")
{
   return object->getAngularVelocity();
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setAngularVelocity, void, (VectorF velocity), ,
                   "Set the angular velocity for a Newton mode afxCamera.\n\n"
                   "@param velocity The angular velocity infor form of \"x y z\".\n"
                   "@note Only takes affect when afxCamera::newtonRotation is set to true.")
{
   object->setAngularVelocity(velocity);
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setAngularForce, void, (F32 force), ,
                   "Set the angular force for a Newton mode afxCamera.\n\n"
                   "@param force The angular force applied when attempting to rotate the afxCamera."
                   "@note Only takes affect when afxCamera::newtonRotation is set to true.")
{
   object->setAngularForce(force);
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setAngularDrag, void, (F32 drag), ,
                   "Set the angular drag for a Newton mode afxCamera.\n\n"
                   "@param drag The angular drag applied while the afxCamera is rotating."
                   "@note Only takes affect when afxCamera::newtonRotation is set to true.")
{
   object->setAngularDrag(drag);
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setMass, void, (F32 mass), ,
                   "Set the mass for a Newton mode afxCamera.\n\n"
                   "@param mass The mass used during ease-in and ease-out calculations."
                   "@note Only used when afxCamera is in Newton mode.")
{
   object->setMass(mass);
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, getVelocity, VectorF, (), ,
                   "Get the velocity for the afxCamera.\n\n"
                   "@returns The afxCamera's velocity in the form of \"x y z\"."
                   "@note Only useful when the afxCamera is in Newton mode.")
{
   return object->getVelocity();
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setVelocity, void, (VectorF velocity), ,
                   "Set the velocity for the afxCamera.\n\n"
                   "@param velocity The afxCamera's velocity in the form of \"x y z\"."
                   "@note Only affects the afxCamera when in Newton mode.")
{
   object->setVelocity(velocity);
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setDrag, void, (F32 drag), ,
                   "Set the drag for a Newton mode afxCamera.\n\n"
                   "@param drag The drag applied to the afxCamera while moving."
                   "@note Only used when afxCamera is in Newton mode.")
{
   object->setDrag(drag);
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setFlyForce, void, (F32 force), ,
                   "Set the force applied to a Newton mode afxCamera while moving.\n\n"
                   "@param force The force applied to the afxCamera while attempting to move."
                   "@note Only used when afxCamera is in Newton mode.")
{
   object->setFlyForce(force);
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setSpeedMultiplier, void, (F32 multiplier), ,
                   "Set the Newton mode afxCamera speed multiplier when trigger[0] is active.\n\n"
                   "@param multiplier The speed multiplier to apply."
                   "@note Only used when afxCamera is in Newton mode.")
{
   object->setSpeedMultiplier(multiplier);
}

//-----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setBrakeMultiplier, void, (F32 multiplier), ,
                   "Set the Newton mode afxCamera brake multiplier when trigger[1] is active.\n\n"
                   "@param multiplier The brake multiplier to apply."
                   "@note Only used when afxCamera is in Newton mode.")
{
   object->setBrakeMultiplier(multiplier);
}

//----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, isEditOrbitMode, bool, (), ,
                   "Is the afxCamera in edit orbit mode?\n\n"
                   "@returns true if the afxCamera is in edit orbit mode.")
{
   return object->isEditOrbitMode();
}

//----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setValidEditOrbitPoint, void, (bool validPoint), ,
                   "Set if there is a valid editor afxCamera orbit point.\n"
                   "When validPoint is set to false the afxCamera operates as if it is "
                   "in Fly mode rather than an Orbit mode.\n\n"
                   "@param validPoint Indicates the validity of the orbit point."
                   "@note Only used when afxCamera is in Edit Orbit Mode.")
{
   object->setValidEditOrbitPoint(validPoint);
}

//----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, setEditOrbitPoint, void, (Point3F point), ,
                   "Set the editor afxCamera's orbit point.\n\n"
                   "@param point The point the afxCamera will orbit in the form of \"x y z\".")
{
   object->setEditOrbitPoint(point);
}

//----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, autoFitRadius, void, (F32 radius), ,
                   "Move the afxCamera to fully view the given radius.\n\n"
                   "@note For this operation to take affect a valid edit orbit point must first be specified.  See afxCamera::setEditOrbitPoint().\n"
                   "@param radius The radius to view.")
{
   object->autoFitRadius(radius);
}

//----------------------------------------------------------------------------

DefineEngineMethod( afxCamera, lookAt, void, (Point3F point), ,
                   "Point the afxCamera at the specified position.  Does not work in Orbit or Track modes.\n\n"
                   "@param point The position to point the afxCamera at.")
{
   object->lookAt(point);
}

which was essentially a copy of the Camera class' console API - adjusted setOrbitObject and setOrbitPoint (those are probably broken as they are above mainly because any script that currently calls those for a regular camera will certainly fail if called on an afxCamera unless the parameters are changed - defeating the point of doing this in the first place).

No more console errors switching between game and editor modes and it all appears to function (with the exception noted above).

#16 Awesome, good to hear it's working out!

#17 I have a question about generating large nav meshes. Is there a maximum size for generating a single mesh?

I'm trying to nav mesh a rather large terrain, and currently I'm planning to just section it off into key areas and generate nav meshes in those areas. Obviously not the most ideal solution, so I was wondering if there's some nice way to play with settings to get a large nav-mesh to generate nicely. I know that if I play with the voxel size I can get larger ones, but my doorways become unenterable according to the nav mesh then (I really need .3 or less).

Currently when I try to generate a large one, it ends up crashing on me. When I go into debug it gives a bad_alloc error on creation. Am I just running out of memory or is there some trick to it?

Thanks.

#18 Great product Daniel - have this working with AFX and UAISK combined. I also have the bad_alloc error on generating a navmesh on a large terrain. What's the maximum size (if any?)

#19 Oh dear, I was hoping I wouldn't get questions on this ;P. Basically, the navmesh generation algorithm has way too many places where memory allocation could go bad.

The first thing to do is ensure you're not storing intermediate results if you want to build a large mesh. This is a ton of data that's not necessarily, and you'll hardly ever need it unless something is going really wrong with portals (the navmesh ones, not the Torque ones) or you really like looking at voxels.

If it's still crashing, the only thing to do is play with voxel sizes and tile sizes. Unfortunately, I'm not very good at predicting what effects a certain parameter change will have on the algorithm. I'm pretty much out of action as far as Torque programming goes until March (see here), but as soon as I get back home I'll be working on this.

I thought that I'd prevented crashes, so that's the first thing I'll be patching for you guys. After that, I can put some effort into delving into where all the memory goes and how to make the process more efficient. Because, to be frank the final navmesh isn't a ton of memory, so it shouldn't pose a problem. It's the generation that's the problem, and because the mesh is generated tile-by-tile, the memory usage should be fairly constant.

Anyway. To sum up: I thought I had prevented crashing, but apparently not. I'll be fixing that before the end of March, and then I'll start to work on solving the root cause of the problem.

#20 Perfect! Thanks Daniel. For now I'll keep the nav meshes small in towns, I take it you can have more than one nav mesh on a map (one per filename) Not tried it yet.. so if you had two areas on a map needing a nav mesh area, this would be possible?