navArea.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2015 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/



#pragma once

#include "vrfNavigation/vrfNavigationDefines.h"
#include <string>
#include "vrfNavigation/navDataTag.h"
#include "vrfNavigation/navSectorName.h"
#include <matrix/vlVector.h>
#include "vrfutil/localVertexList.h"
#include "boost/shared_ptr.hpp"
#include "boost/weak_ptr.hpp"
#include "vrfutil/rwString.h"
#include "vrfutil/rwUUID.h"

class Coordinate_System;
class DtExtent;
class DtVrfObject;
class DtTerrainInterface;
class DtNavBot;

enum DtOnGraphVertexVisitedResult
{
   DtOnGraphVertexVisited_IgnoreVertex_GoOn,
   DtOnGraphVertexVisited_IgnoreVertex_StopWithBestSoFar,
   DtOnGraphVertexVisited_StopOnThisVertex,
   DtOnGraphVertexVisited_VertexIsTheBestSoFar_GoOn,
   DtOnGraphVertexVisited_NeedToCheckRefinePathToThisVertex
};

enum DtOnPathToGraphVertexComputedResult
{
   DtOnPathToGraphVertexComputed_IgnoreVertex_GoOn,
   DtOnPathToGraphVertexComputed_IgnoreVertex_StopWithBestSoFar,
   DtOnPathToGraphVertexComputed_StopOnThisVertex,
   DtOnPathToGraphVertexComputed_VertexIsTheBestSoFar_GoOn,
};

typedef std::set<DtNavSectorName> DtNavSectorNames;

//Base class for asynchronous Nav Area queries.
//In this context asynchronous means non-blocking, but performed
//in a single-thread. These queries are time-sliced by
//gameware's infrastructure.  
//Will be ticked by the navArea's update function.

class DT_DLL_vrfNavigation DtNavAreaQuery
{
public:
   typedef boost::shared_ptr<DtNavAreaQuery> Ptr;

   DtNavAreaQuery() { };
   virtual ~DtNavAreaQuery() { };

   virtual bool complete() = 0;
   virtual bool tick() = 0;
   virtual bool success() = 0;

   virtual bool navDataChanged() = 0;
   virtual bool outOfWorkingMemory() = 0;
   virtual bool hadComputationError() = 0;

   virtual std::vector<DtVector> results() = 0;
   virtual std::vector<DtVector> debugPoints() { return std::vector<DtVector>(); };
   virtual void* internalQuery() = 0;
};

//Query that can be used when there is no valid navData.
class DT_DLL_vrfNavigation DtNavAreaNullQuery : public DtNavAreaQuery
{
public:
   DtNavAreaNullQuery() : DtNavAreaQuery() { };
   virtual ~DtNavAreaNullQuery() { };

   virtual bool complete() { return true; };
   virtual bool tick() { return true; };
   virtual bool success() { return true; };
   virtual void cancel() {};
   virtual bool navDataChanged() { return false; };
   virtual bool outOfWorkingMemory() { return false; };
   virtual bool hadComputationError() { return false; };
   virtual std::vector<DtVector> results() { return std::vector<DtVector>(); };
   virtual void *internalQuery(void) { return 0; };
};

struct DT_DLL_vrfNavigation DtNavAreaConfig
{
   DtNavAreaConfig() : workingMemorySize(16), 
      regenerateAtRuntime(true), maxRegenerationThreads(2), regenerationDelay(2.5) {};

   int workingMemorySize;

   bool regenerateAtRuntime;

   int maxRegenerationThreads;

   double regenerationDelay;

};

class DT_DLL_vrfNavigation DtNavRegenRequestIdData
{
public:
   virtual ~DtNavRegenRequestIdData() {};

protected:
   DtNavRegenRequestIdData() {};
   DtNavRegenRequestIdData(const DtNavRegenRequestIdData&) {};
};


typedef boost::weak_ptr<DtNavRegenRequestIdData> DtNavRegenRequestId;

class DT_DLL_vrfNavigation DtNavArea
{
public:
   struct DtNavDataDebugInfo
   {
      DtString navAreaName;
      int port;
      std::vector<DtRwString> profiles;
      DtString status;
   };

   typedef DtNavArea* (*DtNavAreaCreatorFcn)();
   typedef DtOnGraphVertexVisitedResult (*DtPointOfInterestEvaluatorFcn)(const DtVector& localPoint, void* userData);
   typedef DtOnGraphVertexVisitedResult (*DtPointOfInterestNavTagEvaluatorFcn)(const DtVector& localPoint, const DtNavTag& tag, void* userData);
   typedef void (*DtSearchAreaPointCostModifierEvaluatorFcn)(const DtVector& localPoint, float* currentCost, void* userData);
   typedef DtOnPathToGraphVertexComputedResult(*DtPathCalculatedEvaluatorFcn)(const DtVector& localPoint, double pathCost, void* userData);
   typedef void(*DtSectorRegenerationCb)(void* userData);

   static DtNavArea* create();
   static void setNavAreaCreatorFcn(DtNavAreaCreatorFcn fcn);

   static bool navAreaDebuggingEnabled();
   static void setNavAreaDebuggingEnabled(bool enable);

   virtual ~DtNavArea() {};
   virtual bool initialize(Coordinate_System* coordSys, DtTerrainInterface* terrainIf, DtNavAreaConfig config,
      std::vector<DtString> profiles = std::vector<DtString>()) = 0;
   virtual void update(float deltaTimeInSeconds) = 0;
   virtual bool loadNavData(const DtString& path, const DtVariableBindingsList& variableBindings = 
      DtReaderWriter::nullVariableReference(), bool objectNavData = false) = 0;
   virtual bool inNavArea(const DtVector& localPos) = 0;
   virtual bool validPosition(const DtString& profile, const DtVector& localPos, DtNavTag* navTag = 0) = 0;
   
   //Returns true if this area is valid for the given navigation profile. 
   virtual bool validForProfile(const DtString& profile) const = 0;

   virtual DtNavDataDebugInfo* debugInfo() = 0;

   virtual void setExtent(DtExtent* e) = 0;
   virtual DtExtent localExtent() = 0;

   virtual void cancelQuery(DtNavAreaQuery::Ptr) = 0;

   virtual DtNavAreaQuery::Ptr findNearbyPointOfInterest(const DtString& profile, const DtVector& startLocalPos,
      int tag = DtNavDataTagAny, double propagationRadius = 200.,
      DtPointOfInterestEvaluatorFcn evalFcn = 0, DtPathCalculatedEvaluatorFcn pathFcn = 0, void* evalFcnUserData = 0) = 0;

   virtual DtNavAreaQuery::Ptr findNearbyPointOfInterestUsingNavTag(const DtString& profile, const DtVector& startLocalPos,
      int tag = DtNavDataTagAny, double propagationRadius = 200.,
      DtPointOfInterestNavTagEvaluatorFcn evalFcn = 0, DtPathCalculatedEvaluatorFcn pathFcn = 0, void* evalFcnUserData = 0) = 0;

   virtual DtNavAreaQuery::Ptr findBestExitPoint(const DtString& profile, DtNavBot* searcher,
      const DtVector& startLocalPos, const DtVector& destination,
      int tag = DtNavDataTagAny, double propagationRadius = 200.,
      DtPointOfInterestEvaluatorFcn evalFcn = 0, DtPathCalculatedEvaluatorFcn pathFcn = 0, void* evalFcnUserData = 0) = 0;

   virtual bool findInsidePositionFromOutsidePosition(const DtString& profile,
      double searchRadius, double searchHeight, const DtVector& fromFromHere,
      DtVector& result, int& halfEdgeType) = 0;

   virtual DtNavAreaQuery::Ptr findBestPathTo(const DtString& profile, const DtVector& start,
      const std::vector<DtVector>& localDestinationPositions, DtNavBot* searcher, int tag = -1,
      DtSearchAreaPointCostModifierEvaluatorFcn = 0, DtPointOfInterestEvaluatorFcn = 0, DtPathCalculatedEvaluatorFcn = 0,
      void* usrData = 0, bool startMovingWhenFound = false) = 0;

   virtual DtNavAreaQuery::Ptr findPathToLocation(const DtString& profile, const DtVector& start,
      const DtVector& destination, bool useAbstractGraphs = true,
      const DtVector& locationToAvoid = DtVector(), double avoidanceRadius = 0) = 0;

   virtual bool findFarthestPositionAlongHeading(const DtString& profile, const DtVector& start,
      double heading, double maxDistance, DtVector& result, bool& reachedMaxDist) = 0;

   //User callback to check randomly generated points. The callback function
   //should return true if the point is acceptable.
   typedef bool (*DtLocalPointUserEvalCallback)(const DtVector& localVector, DtNavAreaQuery* query, void* userData);
   static bool emptyCallback(const DtVector&, DtNavAreaQuery*, void*);

   //Generate some number of random points.
   //If localAccessibilityPoint is set, all points must be navigable
   //from the access point.
   //If boundingArea is set, all points must be inside the area, 
   //ignoring elevation. Note that this will not cause points to be
   //generated outside the navArea.
   //If boundingArea is not set, and radius is set, points will be generated
   //using radius as a maximum distance from accessibilityPoint.
   //If minDistanceBetweenPoints is set, generated points will be tested
   //against the rest of the set of random points to make sure none are within
   //the given distance of each other.
   //If placementRestriction is set to one of the MovementMode strings (e.g.
   //DtMovementModePreferRoads), points will be chosen that match that criteria.
   //If isStrict is true, only points matching the placementRestriction will be
   //generated, even if we can't create enough to match the desired number.
   //If tightlyPack is true, points closer to access point or bounding area center
   //will be favored.
   //If needLos is true, will try to choose points that should have LOS to the
   //specified access point.
   //If groundClamp is true, points will be ground clamped to the terrain at a point
   //below the original point plus the height of the entity specified in nav generation.
   //If leftOfLine, the points specified will be considered a line, and only points
   //to the left of that line will be generated.
   //If callbackFcn is set, this user function is called on each generated
   //point, to test if each point is acceptable.
   virtual DtNavAreaQuery::Ptr generateRandomPoints(const DtString& profile,
      const DtVector& localAccessibilityPoint = DtVector::zero(),
      double minRadius = -1,
      double maxRadius = -1,
      const DtLocalVertexList& boundingArea = DtLocalVertexList(),
      unsigned numberOfPoints = 1,
      double minDistanceBetweenPoints = 0.0,
      const DtString& placementRestriction = DtString::nullString(),
      bool isStrict = true,
      bool tightlyPack = false,
      bool needLos = false,
      bool groundClamp = false,
      const DtLocalVertexList& leftOfLine = DtLocalVertexList(),
      DtLocalPointUserEvalCallback callbackFcn = emptyCallback,
      void* userData = 0) = 0;

   virtual bool tagVolumesToBeIntegrated() const = 0;

   DtVrfObject* attachedObject() { return myAttachedObject; }
   void setAttachedObject(DtVrfObject* object) { myAttachedObject = object; }

  virtual  std::vector<DtVector> searchInArea(const DtString& profile,
      const DtVector& startLocalPos, double radius, double postSpacing, DtNavBot* searcher,
      DtPointOfInterestEvaluatorFcn evalFcn = 0, void* evalFcnUserData = 0, int tag = -1) = 0;

  virtual unsigned newNavTagVolumeId() = 0;

  virtual void associateNavTagVolumeIdWithObject(unsigned tagVolumeId, const DtUUID& objectUUID) = 0;

  virtual DtUUID uuidFromNavTagVolumeId(unsigned navTagId) = 0;

  virtual unsigned navTagVolumeIdFromUuid(const DtUUID& objectUUID) = 0;

  virtual const DtNavSectorNames& sectorsQueuedForRegeneration() const = 0;

  virtual const DtNavSectorNames& sectorsBeingRegenerated() const = 0;

  virtual void addSectorRegenerationCallback(DtSectorRegenerationCb cb, void* usr) = 0;
  virtual void removeSectorRegenerationCallback(DtSectorRegenerationCb cb, void* usr) = 0;

  virtual DtNavRegenRequestId requestNavDataGeneration(const DtVector& location, double radius,
     const std::set<DtString>& profiles = std::set<DtString>()) = 0;

  virtual void requestNavDataReversion(DtNavRegenRequestId id) = 0;

protected:
   static DtNavAreaCreatorFcn theNavAreaCreatorFcn;

   static bool theNavAreaDebuggingEnabled;

   DtVrfObject* myAttachedObject;
};