vrfObject.h

Go to the documentation of this file.

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

#pragma once


#include "vrfobjcore/vrfobjcoreDefines.h"
#include "vrfobjcore/simObjectFactory.h"
#include "vrfobjcore/simObjectCallbackInfo.h"
#include "vrfobjcore/obstacleAreaCompatilibility.h"
#include "vrfobjcore/attachedTerrain.h"
#include "vrfobjcore/vrfObjectPredicateCallbackInfo.h"
#include "vrfobjcore/luaScriptInterfaceExtension.h"
#include "vrfobjcore/vrfObjectReference.h"
#include "geometry/extent.h"
#include "features/featureGeometry.h"

#include "vrfutil/readerWriter.h"
#include "vrfutil/rwString.h"
#include "vrfutil/rwEntityIdentifier.h"
#include "vrfutil/rwUUID.h"
#include "vrfutil/rwObjectType.h"
#include "vrfutil/rwBoolean.h"
#include "vrfutil/localVertexList.h"
#include "vrfutil/rwVector.h"
#include "vrfutil/noArgumentCallbackList.h"
#include "vl/globalObjectDesignator.h"
#include <vlpi/entityIdentifier.h>

#include <vl/hostStructs.h>
#include <vlpi/appearance.h>
#include <vlutil/vlList.h>
#include <matrix/geodeticCoord.h>

#include <boost/smart_ptr/shared_ptr.hpp>
#include <tbb/spin_rw_mutex.h>

class DtVrfChordIntersectionRecord;
class DtVrfUnderwaterAcoustics;
class DtVrfObjectStateRepository;
class DtSimObjectStateRepository;
class DtSimObjectNetInterface;
class DtStateRepository;
class DtVrfObjectParameters;
class DtVrfObjectSubComponentTypes;
class DtSimObjectCallbackInfo;
class DtVrfObjectMessage;
class DtVrfObjectManager;
class DtSimManager;
class DtVrfObjectSubComponentTypes;
class DtSimTaskManager;
class DtSimRadio;
class DtSimComponentManager;
class DtVrfObjectPlanManager;
class DtIfCreateVrfObject;
class DtIfModifyVrfObject;
class DtIfVrfObjectCreated;
class DtReflectedEntity;
class DtReflectedExtAggregate;
class DtReflectedEnvironmentProcess;
class DtVrfObject;
class DtVrfObjectPredicate;
class DtLclVerticesNotEqualPredicate;
class Coordinate_System;
class DtAttachedTerrain;
class DtReflectedObject;
class DtPhysicalWorld;
class DtObjectConsole;
class DtSetDataManager;
class DtVrfObjectCommunicationInterface;
class DtRadioDescriptorList;
class DtSettingsObject;
class DtVrfObjectTerrainPreloadManager;
class DtScriptInterfaceHandler;
class DtRangeRingsParametersPublisher;
class DtMovingObjectParameters;
class DtVrfObjectNavInterface;
class DtNavInterfaceManager;
class DtCriticalSection;
class DtTerrainGeometryHandle;

typedef void (*DtVrfObjectCallbackFunction)(DtVrfObject* obj, void* userData);
typedef void (*DtObjectDataChangedCallbackFunction)(DtVrfObject* obj, int changeFlag, void* userData);

typedef DtCallbackList<DtVrfObject*> DtVrfObjectCallbackList;

class DtVrfObject;
struct DtImportScenarioData;

class DT_DLL_vrfobjcore DtVrfObjectDeletionTracker
{
public:

   DtVrfObjectDeletionTracker(DtVrfObject* simObject)
   : mySimObject(simObject)
   {

   }

   virtual DtVrfObject* object() { return mySimObject; }
   virtual bool objectValid() { return mySimObject != NULL; }
   virtual void invalidateObject() { mySimObject = NULL; }

protected:

   DtVrfObject* mySimObject;
};

typedef boost::shared_ptr<DtVrfObjectDeletionTracker> DtVrfObjectDeletionHandle;

class DT_DLL_vrfobjcore DtRwVrfObjectName : public DtRwString
{
public:
   DtRwVrfObjectName();
   DtRwVrfObjectName(const DtString& name, DtReaderWriterRegistry* const parentRegistry);
   DtRwVrfObjectName(const DtSymbolString& name, DtReaderWriterRegistry* const parentRegistry);

   DtRwVrfObjectName& operator=(const DtString&);

   virtual void setVrfObject(DtVrfObject*);

   virtual DtlObjPtr getData(DtlObjPtr args, const SearchPaths& searchPaths,
      const DtVariableBindingsList& variableBindings);

protected:
   DtVrfObject* myParent;
};

class DT_DLL_vrfobjcore DtVrfObjectUUID : public DtRwUUID
{
public:
   DtVrfObjectUUID(const DtString& name, DtReaderWriterRegistry* const parentRegistry);
   DtVrfObjectUUID(const DtSymbolString& name, DtReaderWriterRegistry* const parentRegistry);

   DtVrfObjectUUID& operator=(const DtUUID&);

   virtual void setVrfObject(DtVrfObject*);

   virtual void setRecreateUUIDOnLoad(bool);
   
   virtual void setResolved(bool);

   virtual DtlObjPtr getData(DtlObjPtr args, const SearchPaths& searchPaths,
      const DtVariableBindingsList& variableBindings);

protected:
   virtual void noRwValueSpecified();

protected:
   bool myRecreateOnLoad;
   bool myResolved;
   DtVrfObject* myParent;
};

class DT_DLL_vrfobjcore DtVrfObject : public DtReaderWriter
   , public DtObjectDebugger<DtVrfObject>
{
public:
   enum ChangeFlag
   {
      MarkingText = 1,
      ForceType,
      ObjectLabel,
      OverlayParent,
      ObjectType,
      SubordinateOfForceLevel
   };

   typedef std::pair<DtVrfObjectCallbackFunction, void*> DtVrfObjectCallbackDataPair;
   typedef std::pair<DtVrfObject*, DtVrfObjectCallbackDataPair> DtVrfObjectCallbackDataPair2;
   typedef std::pair<DtObjectDataChangedCallbackFunction, void*> DtVrfObjectDataChangedCallbackDataPair;
   typedef std::list<DtLuaScriptInterfaceExtension::CreatorUserPair> ScriptInterfaceExtensions;

protected:

   DtVrfObject();

public:

   DtVrfObject(
      const DtObjectType & objectType, 
      DtVrfObjectManager* vrfObjectManager,
      bool createLocalObject = true,
      bool publishLocalObject = true,
      const DtEntityIdentifier& objectIdentifier = DtEntityIdentifier::nullId(),
      const DtGlobalObjectDesignator* globalId = 0,
      DtReflectedObject* reflectedObject = 0,
      const DtString & objectName = DtString::nullString(),
      const DtString & objectLabel = DtString::nullString(),
      DtForceType forceType = DtForceOther,
      const DtList* vertices = 0,
      const DtTaitBryan* orientation = 0,
      bool projection = false,
      bool closedFigure = false,
      const DtAppearance& appearance = DtAppearance::nullAppearance(),
      const DtString & readerWriterName = "vrf-object", 
      DtReaderWriterRegistry* parentRegistry = 0,
      const DtUUID& uuid = DtUUID::nullUUID(),
      bool connectToRadioNetowrk = true);

   virtual ~DtVrfObject();

   static void enableSingleObjectMode();
   static bool singleObjectModeActive();

   virtual bool create(bool createNetworkInterface = true);

   virtual bool finalizeObjectCreation();

   virtual void finalizeObjectRead();

   virtual void setSimulationCapable(bool);
   virtual bool simulationCapable() const;

   virtual void createCommunicationsInterface();

   virtual void createCommunicationsInterface(const DtRadioDescriptorList& descList);

   virtual void createSetDataManager();

   virtual int vrfSessionId() const;

   virtual bool init();


   virtual void tick();

   virtual void startTick();
   virtual void tickComponents();
   virtual void endTick();

   virtual void tickPublisherOnly();

   virtual bool createRepository(DtVrfObjectParameters* parameterEntry);
   virtual bool createTaskManager();
   virtual bool createScriptInterfaceHandler();
   virtual bool createComponentManager();
   virtual bool createVrfObjectPlanManager();
   virtual bool createRadio();
   virtual bool createNavigationInterfaceManager();

   virtual void setNavigationEnabled(bool);
   virtual bool navigationEnabled() const;

   virtual void addToPotentialLuaScripts(int);
   virtual int potentialLuaScripts() const;

   virtual int scenarioRunId() const;

   virtual double timeOfDay() const;

   virtual double dateAndTimeOfDay() const;

   virtual DtSharedVrfObjectReference sharedReference();
   virtual DtSharedVrfObjectReference sharedReference() const;

   virtual double illumination() const;

   virtual DtVrfObject* weather() const;

   virtual MAKVRinTerra::DtFeatureGeometry featureGeometry() const;

   virtual void updateIllumination() const;

   virtual void updateWeather();

   virtual void setRangeRingsParametersPublisherTickRange(double d);

   virtual void createAndInitializeRangeRingsParameterPublisher();

   virtual bool needsIlluminationUpdate() const;

   virtual bool isOnTopOf(const DtVrfObject*) const;
   virtual bool isOnTopOf(const DtVrfObject*, double d) const;

   virtual bool isSimulationObject() const;
   virtual bool isEntity() const;
   virtual bool isUnit() const;

   virtual bool intersect(const DtChord&, DtVrfChordIntersectionRecord* record = 0) const;

   virtual bool checkAndDisembarkIfEmbarked(const DtVector& localPosition);

   virtual bool checkIfMoveOntoEmbarked(const DtVector& localPosition, DtVrfObject*& hit, const std::list<DtUUID>& additionalIgnore = std::list<DtUUID>());

   virtual bool hasHighFidelityObjectGeometryModel() const;

   virtual bool isEmbeddedInTerrain() const;

   virtual bool needsWeatherAreaUpdate() const;

   virtual bool isGlobalPlan() const;

   virtual const DtSimManager* simManager() const;
   virtual DtSimManager* simManager();

   virtual DtSimTaskManager* taskManager() const;
   virtual DtScriptInterfaceHandler* scriptInterfaceHandler() const;
   virtual DtSimComponentManager* componentManager() const;
   virtual DtVrfObjectPlanManager* vrfObjectPlanManager() const;
   virtual DtSimRadio* radio() const;

   virtual DtVrfObjectStateRepository* vrfState() const;

   virtual DtExtent extent() const;

   virtual DtExtent roughExtent() const;

   const DtVrfObjectParameters* parameterEntry() const;

   const DtMovingObjectParameters* movingObjectParameterEntry() const;

   virtual void expandExtent(DtExtent& extent) const;
   
   virtual void sendVrfObjectCreated(unsigned long requestId = 0, bool requestCreated = true);
   
   virtual void setupFromMessageContent(DtIfModifyVrfObject* ifModVrfObject);

   virtual void setIsVrfSimulatedObject(bool b);

   virtual bool isVrfSimulatedObject() const;
   virtual bool isVrfSimulated() const
   {
      return isVrfSimulatedObject();
   }

   virtual bool isSimulatingComponents() const;

   virtual void save(std::string&);

   virtual void putSelf(std::string& fp, int indentLevel = 0, bool writeUnspecified = true,
      const DtFilename& path = DtReaderWriter::appPath());

   virtual void getSelf(DtlObjPtr args, const DtReaderWriter::SearchPaths& searchPaths,
      const DtVariableBindingsList& variableBindings);  

   virtual bool validNameLength(const DtString& name) const;

   virtual bool setMarkingText(const DtString & name, bool rename = true);

   virtual void addVrfObjectChangedCallback(
      DtVrfObjectCallbackFunction function, void* userData);
   virtual void removeVrfObjectChangedCallback(
      DtVrfObjectCallbackFunction function, void* userData);

   virtual void addNavigationInterfaceChangedCallback(
      DtVrfObjectCallbackFunction function, void* userData);
   virtual void removeNavigationInterfaceChangedCallback(
      DtVrfObjectCallbackFunction function, void* userData);

   virtual void addVerticesChangedCallback(
      DtVrfObjectCallbackFunction function, void* userData);
   virtual void removeVerticesChangedCallback(
      DtVrfObjectCallbackFunction function, void* userData);

   virtual void addObjectDataChangedCallback(DtObjectDataChangedCallbackFunction, void*);
   virtual void removeObjectDataChangedCallback(DtObjectDataChangedCallbackFunction, void*);
   virtual void invokeObjectDataChangedCallbacks(ChangeFlag);

   virtual void addRelativeVerticesChangedCallback(
      DtVrfObjectCallbackFunction function, void* userData);
   virtual void removeRelativeVerticesChangedCallback(
      DtVrfObjectCallbackFunction function, void* userData);

   virtual void addVrfObjectPredicateCallback(
      DtVrfObjectPredicateCallbackFunction function, 
      const DtVrfObjectPredicate& predicate, DtTime evaluationPeriod = 0, 
      void* userData = 0);
   virtual void removeVrfObjectPredicateCallback(
      DtVrfObjectPredicateCallbackFunction function, 
      const DtVrfObjectPredicate& predicate, DtTime evaluationPeriod = 0, 
      void* userData = 0);

   virtual int predicateCallbackCount() const;

   virtual void invokeVrfObjectPredicateCallbacks();

   virtual void setCoordinateSystem(const Coordinate_System* coordinateSystem);

   virtual const DtVrfObjectManager* simObjectManager() const;
   virtual DtVrfObjectManager* simObjectManager();
   virtual void setSimObjectManager(DtVrfObjectManager* simObjectManager);

   virtual bool createNetInterface();

   virtual void setGlobalId(const DtGlobalObjectDesignator & id);
   virtual const DtGlobalObjectDesignator & globalId() const;

   virtual const DtString & globalIdString() const;

   virtual bool baseSetMarkingText(const DtString & name);
   virtual const DtString& markingText() const;

   virtual const DtString& objectName() const;

   virtual void addNameAlias(const DtString& name);

   virtual void unregisterAliases();

   virtual void setUUID(const DtUUID&);

   virtual const DtUUID& uuid() const;

   virtual const DtString & objectLabel() const;
   virtual void setObjectLabel(const DtString & objectLabel);

   virtual DtForceType forceType() const;
   virtual void setForceType(DtForceType f);

   virtual void setIsSubordinateOfForceLevel(bool);
   virtual bool isSubordinateOfForceLevel() const;

   virtual const DtString & overlayParent() const;
   virtual void setOverlayParent(const DtString & overlayParent);

   virtual DtStateRepository* netState();
   virtual const DtStateRepository* netState() const;

   virtual DtSimObjectNetInterface* netInterface();
   virtual const DtSimObjectNetInterface* netInterface() const;
   virtual void setNetInterface(DtSimObjectNetInterface* netInterface);

   virtual void setObjectIdentifier(const DtEntityIdentifier & objectId);
   virtual const DtEntityIdentifier & objectIdentifier() const;

   virtual const DtString & objectIdentifierString() const;

   virtual bool isLocal() const;


   virtual void setPublishObject(bool publishObject);
   virtual bool publishObject() const;

   virtual DtString type() const;

   virtual DtString objectClassType() const; 
   virtual void setObjectClassType(const DtString & objectClassType);

   virtual void clearVerticesChangedCallbacks();

   virtual void clearRelativeVerticesChangedCallbacks();

   virtual void clearPredicateCallbacks();

   static void addSimObjectCreatorFcn(const DtString & type, 
      DtSimObjectCreatorFcn fcn);

   static void objectAboutToBeRemoved(DtVrfObject * msg, void * usr);
   virtual void processObjectAboutToBeRemoved(DtVrfObject*);

   static DtSimObjectFactory* factory();
   static void setFactory(DtSimObjectFactory* factory);

   virtual DtSimObjectStateRepository* simState();
   virtual const DtSimObjectStateRepository* simState() const;
   virtual void setSimState(DtVrfObjectStateRepository* simState);

   void setEntityType(const DtEntityType & entityType);
   const DtEntityType & entityType() const;

   void setDestroyed(bool destroyed);
   bool isDestroyed() const;

   virtual void place(const DtVector& location, bool* dataAvailable = 0, 
      bool requireAllData = false);

   virtual void place(const DtReal heading, bool* dataAvailable = 0, 
      bool requireAllData = false);

   virtual void place(const DtVector& location, const DtReal heading, 
      bool* dataAvailable = 0, bool requireAllData = false);

   const DtString & echelonIdString() const;

   virtual DtSharedVrfObjectReference leadEntity() const;

   virtual DtSharedVrfObjectReference firstSubordinate() const;

   virtual DtSharedVrfObjectReference lastSubordinate() const;

   virtual DtSharedVrfObjectReference firstHealthySubordinate() const;

   virtual void echelonIdChanged() {}

   virtual const DtObjectId & objectId() const;
   virtual const DtObjectType& objectType() const;

   virtual bool isEmbarked() const;

   virtual DtVector locationRelativeTo(const DtVector&, DtVrfObject* relativeTo) const;

   virtual DtVector velocityRelativeTo(const DtVector&, DtVrfObject* relativeTo) const;

   virtual DtVector accelerationRelativeTo(const DtVector&, DtVrfObject* relativeTo) const;

   virtual DtTaitBryan orientationRelativeTo(const DtTaitBryan&, DtVrfObject* relativeTo) const;

   virtual DtVrfObject* embarkedOn() const;

   virtual bool isEmbarkedOn(const DtUUID& parent) const;

   DtAttachedTerrain* terrainAttachedTo();
   const DtAttachedTerrain* terrainAttachedTo() const;

   virtual const DtPhysicalWorld* physicalWorld() const;
   virtual DtPhysicalWorld* physicalWorld();

   void setAboutToBeRemoved(bool);
   bool aboutToBeRemoved() const;

   virtual DtOutputStream& objectConsoleDebug(const DtString& channel = "") const;
   virtual DtOutputStream& objectConsoleVerbose(const DtString& channel = "") const;
   virtual DtOutputStream& objectConsoleInfo(const DtString& channel = "") const;
   virtual DtOutputStream& objectConsoleWarn(const DtString& channel = "") const;
   virtual DtOutputStream& objectConsoleError(const DtString& channel = "") const;

   virtual DtObjectConsole* objectConsole();
   virtual const DtObjectConsole* objectConsole() const;

   virtual DtSetDataManager* setDataManager();
   virtual const DtSetDataManager* setDataManager() const;

   virtual DtVrfObjectCommunicationInterface* communicationInterface();

   virtual DtVrfObjectNavInterface* navInterface();

   virtual DtVrfObjectTerrainPreloadManager* terrainPreloadManager();

   DtVrfObjectSubComponentTypes* vrfSubComponentTypes() const;

   virtual void duplicateVrfSubComponentTypes();

   virtual void restoreDuplicatedVrfSubComponentTypes();

   virtual bool hasPlan() const;

   virtual bool executingPlan() const;

   virtual bool isCurrentlyTasked() const;

   virtual bool isEllipsoid() const;

   virtual void addPostInitFromParamsCallback(DtVrfObjectCallbackFunction fcn,
      void* usr);
   virtual void removePostInitFromParamsCallback(DtVrfObjectCallbackFunction fcn,
      void* usr);

   virtual DtU8 getNextEmitterSystemId();

   static void setDefaultNotifyLevel(DtNotifyLevelType level);
   static DtNotifyLevelType defaultNotifyLevel();

   virtual void addScriptExtension(DtLuaScriptInterfaceExtension::CreatorFcn extension, void* usr);
   virtual void removeScriptExtension(DtLuaScriptInterfaceExtension::CreatorFcn extension, void* usr);
   virtual const ScriptInterfaceExtensions& scriptExtensions() const;

   virtual void regenerateUUIDForImport();

public:

   static DtVrfObject* creator(
      const DtObjectType& objectType,
      DtVrfObjectManager* simObjectManager, 
      bool createLocalObject = true,
      bool publishLocalObject = true,
      const DtEntityIdentifier& objectIdentifier = DtEntityIdentifier::nullId(),
      const DtGlobalObjectDesignator* globalId = 0,
      DtReflectedObject* reflectedObject = 0,
      const DtString & objectName = DtString::nullString(),
      const DtString & objectLabel = DtString::nullString(),
      DtForceType forceType = DtForceOther,
      const DtList* vertices = 0,
      const DtTaitBryan* orientation = 0,
      bool projection = false,
      bool closedFigure = false,
      const DtAppearance& appearance = DtAppearance::nullAppearance(),
      const DtString & readerWriterName = DtString::nullString(), 
      DtReaderWriterRegistry* parentRegistry = 0,
      const DtUUID& uuid = DtUUID::nullUUID(),
      bool connectToRadioNetowrk = true);

   static DtVrfObject* createObject(
      const DtObjectType& objectType,
      DtVrfObjectManager* vrfObjectManager, 
      const DtString & classType, 
      bool createLocalObject = true,
      bool publishLocalObject = true,
      const DtEntityIdentifier& objectIdentifier = DtEntityIdentifier::nullId(),
      const DtGlobalObjectDesignator* globalId = 0,
      DtReflectedObject* reflectedObject = 0,
      const DtString & objectName = DtString::nullString(),
      const DtString & objectLabel = DtString::nullString(),
      DtForceType forceType = DtForceOther,
      const DtList* vertices = 0,
      const DtTaitBryan* orientation = 0,
      bool projection = false,
      bool closedFigure = false,
      const DtAppearance& appearance = DtAppearance::nullAppearance(),
      const DtString & readerWriterName = DtString::nullString(), 
      DtReaderWriterRegistry* parentRegistry = 0,
      const DtUUID& initialUUID = DtUUID::nullUUID(),
      bool connectToRadioNetowrk = true);

   static DtVrfObject* createObject(
      const DtObjectType & objectType,
      DtVrfObjectManager* vrfObjectManager, 
      const DtString & classType, 
      bool createLocalObject = true,
      bool publishLocalObject = true,
      const DtEntityIdentifier& objectIdentifier = DtEntityIdentifier::nullId(),
      const DtGlobalObjectDesignator* globalId = 0,
      DtReflectedObject* reflectedObject = 0,
      const DtString & objectName = DtString::nullString(),
      const DtString & objectLabel = DtString::nullString(),
      DtForceType forceType = DtForceOther,
      const DtVector& location = DtVector::zero(),
      const DtTaitBryan* orientation = 0,
      bool projection = false,
      bool closedFigure = false,
      const DtAppearance& appearance = DtAppearance::nullAppearance(),
      const DtString & readerWriterName = DtString::nullString(), 
      DtReaderWriterRegistry* parentRegistry = 0,
      const DtUUID& uuid = DtUUID::nullUUID(),
      bool connectToRadioNetowrk = true);

   static DtVrfObject* createAndInit(
      DtVrfObjectManager* vrfObjectManager, DtlObjPtr mtlStream);

   static DtVrfObject* createAndInitForSimulationObjectGroup(
      DtVrfObjectManager* vrfObjectManager, DtlObjPtr mtlStream, int flags, int force, const DtVector& geocentricOffsetLocation,
      double offsetRotation = 0.);

   static void verticesChangedCallback(DtVrfObject* obj, 
      DtVrfObjectPredicateEvaluator* predicateEval, void* userData);

   static void relativeVerticesChangedCallback(DtVrfObject* obj, 
      DtVrfObjectPredicateEvaluator* predicateEval, void* userData);

   static void postInitFromParamsCallback(DtVrfObjectStateRepository& stateRepository, void* usr);


   static void readDRThresholdSettingsCallback(
      const DtSettingsObject* settings, void* usr);
   virtual void processReadDRThresholdSettings(const DtSettingsObject* settings);

   virtual void addedToObjectManager();


   virtual void addObjectAboutToBeRemovedCallback(
      DtVrfObjectCallbackList::DtCallbackFunctionType fcn, void* usr);
   virtual void removeObjectAboutToBeRemovedCallback(
      DtVrfObjectCallbackList::DtCallbackFunctionType fcn, void* usr);
   virtual void invokeVrfObjectAboutToBeRemovedCallbacks();


   virtual void addObjectModifiedViaMessageCallback(
      DtVrfObjectCallbackList::DtCallbackFunctionType fcn, void* usr);
   virtual void removeObjectModifiedViaMessageCallback(
      DtVrfObjectCallbackList::DtCallbackFunctionType fcn, void* usr);
   virtual void invokeObjectModifiedViaMessageCallback();


   virtual void addNewSensorContactCallback(
      DtVrfObjectCallbackList::DtCallbackFunctionType fcn, void* usr);
   virtual void removeNewSensorContactCallback(
      DtVrfObjectCallbackList::DtCallbackFunctionType fcn, void* usr);
   virtual void invokeNewSensorContactCallbacks();


   virtual void addSetLocationCompleteCallback(
      DtVrfObjectCallbackList::DtCallbackFunctionType fcn, void* usr);
   virtual void removeSetLocationCompleteCallback(
      DtVrfObjectCallbackList::DtCallbackFunctionType fcn, void* usr);
   virtual void invokeSetLocationCompleteCallbacks();

   virtual DtVrfUnderwaterAcoustics* underwaterAcoustics();

   virtual DtVrfObjectDeletionHandle objectDeletionHandle();

   virtual void updateTerrainEmbeddedGeometry(bool force = false);

protected:

   DtVrfObject(const DtVrfObject& orig);

   DtVrfObject& operator=(const DtVrfObject& orig);

   virtual bool initializeNetInterface();

   virtual void setupStateRepository();

   virtual void setupNetInterface();

   void emptyVertexList();

   void copyVertexList(const DtList& orig);

   virtual void validateObjectType();

   virtual void processPostInitFromParamsCallback(DtVrfObjectCallbackFunction fcn, void* usr);

   virtual void initializeCommunicationInterfaceCallbacks();
   static void setOverlayLayerTaskCallback(const DtVrfObjectMessage* msg, void* usr);
   virtual void processSetOverlayLayerTask(const DtVrfObjectMessage* msg);

   virtual void updateBoundingVolumeBasedOnPosture();

   virtual DtExtent computeExtent() const;

   virtual void initializeObjectGeometryModel();

protected:
   mutable DtExtent              myExtent;      
   mutable bool                  myExtentInvalid;

   DtRwString                    myObjectClassType;

   static DtSimObjectFactory*    theFactory;

   DtRwEntityIdentifier          myObjectIdentifier;
   mutable DtString              myMutableObjectIdStringCache;

   DtRwObjectType                myObjectType;

   DtRwVrfObjectName             myMarkingText;
   DtRwString                    myObjectLabel;
   DtRwString                    myOverlayParent;

   DtGlobalObjectDesignator      myGlobalId;
   mutable DtString              myMutableGlobalIdStringCache;

   DtVrfObjectManager*           mySimObjectManager;

   DtVrfObjectStateRepository*   mySimState;

   DtSimObjectNetInterface*      myNetInterface;

   DtRwBoolean                   myPublishObject;

   bool                          myCreateLocalObject;

   bool                          myIsVrfSimulatedObject;

   DtReflectedObject*            myReflectedObject;
   DtForceType                   myForceType;
   DtList                        myVertices;
   DtTaitBryan                   myOrientation;
   bool                          myProjection;
   bool                          myClosedFigure;
   DtAppearance                  myAppearance;

   DtVrfObjectSubComponentTypes* mySubComponentTypes;

   DtSimManager*                 mySimManager;

   DtSimTaskManager*             myTaskManager;
   DtScriptInterfaceHandler*     myScriptInterfaceHandler;
   DtSimRadio*               myRadio;
   DtSimComponentManager*        myComponentManager;
   DtVrfObjectPlanManager*       myVrfObjectPlanManager;

   DtLocalVertexList             myOvlVertices;
   DtRwVector                    myOvlTargetLocation;
   DtRwVector                    myOvlStartPoint;
   DtRwVector                    myOvlEndPoint;
   DtObstacleAreaCompatilibility myOvlObstacleArea;
   DtRwBoolean                   myOvlObstacleIsBreached;

   DtList myPredicateCallbackList;

   DtVrfObjectCallbackList myVerticesChangedCallbackList;

   DtVrfObjectCallbackList myNavigationInterfaceChangedCallbackList;


   DtList myRelativeVerticesChangedCallbackList;

   std::map<DtObjectDataChangedCallbackFunction, std::set<void*> > myObjectDataChangedCallbackList;

   DtVrfObjectCallbackList myAboutToBeRemovedCallbackList;
   DtVrfObjectCallbackList mySetLocationCompleteCallbackList;
   DtVrfObjectCallbackList myNewSensorContactCallbackList;
   DtVrfObjectCallbackList myObjectModifiedViaMessage;

   DtVrfUnderwaterAcoustics* myVrfUnderwaterAcoustics;

   bool  myAboutToBeRemoved;

   DtObjectConsole* myObjectConsole;

   DtSetDataManager* mySetDataManager;

   DtVrfObjectCommunicationInterface* myCommunicationInterface;

   DtNavInterfaceManager* myNavInterfaceManager;

   DtU8 myNextEmitterSystemId;

   DtVrfObjectTerrainPreloadManager* myTerrainPreloadManager;

   ScriptInterfaceExtensions myScriptInterfaceExtensions;

   DtRangeRingsParametersPublisher* myRangeRingsParametersPublisher;
   DtVrfObjectParameters* myParameterEntry;
   DtMovingObjectParameters* myMovingObject;

   static int theDefaultNotifyLevel;

   int myPotentialLuaScripts;

   mutable double myIlluminationValue;
   double myLastTimeIlluminationCalculated;
   double myLastTimeWeatherAreaCalculated;
   DtGeodeticCoord myLastIlluminationPosition;
   mutable bool myMutableIlluminationCalculatedThisTick;
   mutable tbb::spin_rw_mutex myIlluminationMutex;

   mutable DtVrfObject* myWeatherObject;
   mutable bool myWeatherIsGlobal;
   mutable bool myMutableWeatherObjectUpdatedThisTick;
   mutable tbb::spin_rw_mutex myWeatherMutex;
  
   DtVrfObjectDeletionHandle myObjectDeletionHandle;
   bool myUseDayNightIlluminationModel;

   DtVrfObjectUUID myUUID;
   std::set<DtString> myNameAliasList;
   mutable DtSharedVrfObjectReference mySharedReference;
   mutable bool myWarnedObjectName;
   bool mySimulationCapable;
   const bool myConnectToRadioNetwork;

   DtAttachedTerrain myObjectGeometryModel;

   DtTerrainGeometryHandle* myTerrainEmbeddedGeometry;
   DtTime myLastTerrainEmbeddedGeometryUpdateTime;

   double myLastWeatherHeading;
   bool myDuplicatedSubComponents;
   
};

inline void DtVrfObject::setAboutToBeRemoved(bool b)
{
   myAboutToBeRemoved = b;
}

inline bool DtVrfObject::aboutToBeRemoved() const
{
   return myAboutToBeRemoved;
}

DT_DEFINE_OBJECT_DEBUGGER_NAME(DtVrfObject);