vrforces5.1/classref/local_object_8h_source.html

 /****************************************************************************

  * Copyright (c) 2021 MAK Technologies, Inc.

  * All rights reserved.

  ****************************************************************************/


 #pragma once


 #include "vrfobjcore/vrfobjcoreDefines.h"

 #include "vrfcore/simulationServices.h"

 #include "vrfobjcore/simObject.h"

 #include "vrfobjcore/appearanceLocalObjectFacade.h"

 #include "vrfobjcore/movementLocalObjectFacade.h"

 #include "vrfStateData/stateComponent.h"

 #include "vrfStateData/radioTransmitterStateComponent.h"

 #include "vrfutil/vrfCallbackQueue.h"

 #include "vrfStateData/stateData.h"

 #include <readerWriter/noArgumentCallbackList.h>

 #include "vrfobjcore/luaScriptInterfaceExtension.h"

 #include <vrfutil/echelonId.h>

 #include <vrfutil/vrf4XAPI.h>


 namespace makVrf

 {

    class DtExternalCurrentFrameState;

    class DtExternalNextFrameState;

    class DtLaserDesignatorStateComponent;

    class DtIffStateComponent;

    class DtActiveSonarStateComponent;

    class DtTaskVisualizationStateComponent;

    class DtNavAidRadioTransmitterStateComponent;

    class DtUnderwaterAcousticsStateComponent;

    class DtEmitterSystemStateComponent;

    class DtRadioReceiverStateComponent;

    class DtFrameStateInterface;

    class DtStatePropertiesStateComponent;

 }


 class DtVrfLocalObjectCreateInformation;

 class DtSettingsObject;

 class DtRadioDescriptorList;

 class DtIfModifyVrfObject;

 class DtVrfObjectStateRepository;

 class DtVrfObjectSubComponentTypes;

 class DtVrfObjectCommunicationInterface;

 class DtVrfObjectTerrainPreloadManager;

 class DtAttachedTerrain;

 class DtVrfObjectPlanManager;

 class DtSimTaskManager;

 class DtObjectResourceManager;

 class DtSimRadio;

 class DtScriptInterfaceHandler;

 class DtSimComponentManager;

 class DtSetDataManager;

 class DtSimObjectStateRepository;

 class DtVrfObjectMessage;

 class DtLocalObjectDecorator;

 class DtVrfObjectSubComponentTypes;


 typedef DtLocalObject* (*DtLocalObjectCreatorFcn)(DtSimulationServices*, const DtVrfLocalObjectCreateInformation&);


 struct DtVrfObjectHandoffData

 {

    enum HandoffFlag

    {

       Prepare,

       BeforeConvertToRemote,

       AfterConvertToRemote,

       BeforeConvertToLocal,

       AfterConvertToLocal,

       Abort,

       Failed

    };


    HandoffFlag handoffFlag;

 };


 class DT_DLL_vrfobjcore DtLocalObject : public DtSimObject

 {

 protected:

    DtLocalObject(DtSimulationServices*, const DtVrfLocalObjectCreateInformation&);

    DtLocalObject(DtSimulationServices*);


 public:

    enum ChangeFlag

    {

       ObjectName = 1,

       ForceType,

       ObjectLabel,

       OverlayParent,

       ObjectType,

       SubordinateOfForceLevel

    };


    virtual ~DtLocalObject();


    const makVrf::DtExternalNextFrameState* nextFrameState() const;

    makVrf::DtExternalNextFrameState* nextFrameState();


    template <typename T_Component>

    T_Component* getNextFrameStateComponent()

    {

       return nextFrameState()->getStateComponent<T_Component>();

    }


    template <typename T_Component>

    const T_Component* getNextFrameStateComponent() const

    {

       return nextFrameState()->getStateComponent<T_Component>();

    }


    template <typename T_Component>

    std::vector<T_Component*> getNextFrameStateComponentList()

    {

       return nextFrameState()->getStateComponentList<T_Component>();

    }


    template <typename T_Component>

    const std::vector<T_Component*> getNextFrameStateComponentList() const

    {

       return nextFrameState()->getStateComponentList<T_Component>();

    }


    virtual DtRwProperties& nextFrameStateProperties();


    virtual void setNextFrameActivity(const DtString&);


    virtual void setNextFrameExtendedData(const DtString& key, const DtString& value);

    virtual void setNextFrameExtendedDataMap(const std::map<DtString, DtString>&);

    virtual void setNextFrameExtendedDataMap(const std::map<std::string, std::string>&);

    virtual void clearNextFrameExtendedData();

    virtual void appendNextFrameExtendedData(const std::map<DtString, DtString>& s);

    virtual void setNextFrameExtendedLabel(int, const DtString& value);

    virtual void clearNextFrameExtendedLabels();

    virtual void setNextFrameExtendedLabels(const std::map<int, DtString>&);

    virtual DtAppearance nextFrameAppearance() const;


    virtual void setNextFrameLocalPosition(const DtVector&);

    virtual DtString nextFrameLabel() const;


    virtual const DtVector& nextFrameLocalPosition() const;


    virtual void setNextFrameWorldPosition(const DtVector&);

    virtual const DtVector& nextFrameWorldPosition() const;


    virtual void setNextFrameParentPosition(const DtVector&);

    virtual const DtVector& nextFrameParentPosition() const;


    virtual void setNextFrameLocalOrientationMatrix(const DtDcm&);

    virtual const DtDcm& nextFrameLocalOrientationMatrix() const;


    virtual void setNextFrameLocalOrientationWrtDatabase(const DtTaitBryan&);

    virtual const DtTaitBryan& nextFrameLocalOrientationWrtDatabase() const;


    virtual void setNextFrameLocalOrientation(const DtTaitBryan&);

    virtual const DtTaitBryan& nextFrameLocalOrientation() const;


    virtual const DtTaitBryan& nextFrameTopographicOrientation() const;


    virtual void setNextFrameParentOrientation(const DtTaitBryan&);

    virtual const DtTaitBryan& nextFrameParentOrientation() const;


    virtual void setNextFrameWorldOrientation(const DtTaitBryan&);

    virtual void setNextFrameWorldOrientationMatrix(const DtDcm&);

    virtual const DtTaitBryan& nextFrameWorldOrientation() const;

    virtual const DtDcm& nextFrameWorldOrientationMatrix() const;


    virtual void setNextFrameLocalVertices(const DtList& vertices, DtVector& newGeometricCenter);

    virtual void setNextFrameLocalVertices(const DtLocalVertexList& vertices, DtVector& newGeometricCenter);

    virtual void removeNextFrameVertex(int iIndex);

    virtual void addNextFrameLocalVertex(const DtVector& vertex);

    virtual void addNextFrameLocalVertex(const DtVector& vertex, DtVector& newGeometricCenter);


    virtual void setNextFrameWorldVertices(const std::vector<DtVector>& vertices, DtVector& newGeometricCenter);

    virtual void setNextFrameWorldVertices(const DtVertexList& vertices, DtVector& newGeometricCenter);

    virtual void setNextFrameWorldVertices(const DtList& vertices, DtVector& newGeometricCenter);

    virtual void addNextFrameWorldVertex(const DtVector& vertex, DtVector& newGeometricCenter);


    bool nextFrameIsDestroyed() const;

    int nextFrameDamageState() const;


    virtual void setNextFrameRelativeVertices(const DtLocalVertexList& vertices);


    virtual const DtLocalVertexList& nextFrameLocalVertices() const;

    virtual const DtVertexList& nextFrameWorldVertices() const;

    virtual const DtLocalVertexList& nextFrameRelativeVertices() const;


    virtual double nextFrameHeading() const;

    virtual double nextFramePitch() const;

    virtual double nextFrameRoll() const;


    virtual void setNextFrameLabel(const DtString&);


    virtual const DtString& nextFrameExtendedData(const DtString&) const;


    virtual void setNextFrameIsSubordinateOfForceLevel(bool);

    virtual bool nextFrameIsSubordinateOfForceLevel() const;


    virtual bool nextFrameIsLocal() const;

    bool isLocal() const override;


    virtual void removedFromSimulation();


    virtual void setNextFrameInvisible(bool);

    virtual bool nextFrameInvisible() const;


    virtual void setNextFrameOverlay(const DtString&);


    virtual bool nextFrameSensorsKilled() const;

    virtual void setNextFrameSensorsKilled(bool sensorsKilled);


    virtual void setNextFrameInvisibleSetByUser(bool b);

    virtual bool nextFrameInvisibleSetByUser() const;


    virtual DtString nextFrameOverlay() 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;


    int notifyLevel() const;

    const DtObjectConsole* objectConsole() const;


    virtual void makeInvalid() override;


    bool isValid() const;


    bool publishObject() const;

    int publishFlag() const;

    virtual void setNextFrameIsClutterEntity(bool b);

    virtual bool nextFrameIsClutterEntity() const;

    virtual void setNextFrameIsVrfSimulated(bool);

    virtual bool nextFrameIsVrfSimulated() const;


    virtual bool isRemoteAttachedObject() const;


    virtual void setNextFrameEngagementRules(const DtString&);

    virtual DtString nextFrameEngagementRules() const;


    virtual void setNextFrameIsTasked(bool);

    virtual bool nextFrameIsTasked() const;


    virtual void setNextFrameIndependentlyTasked(bool);

    virtual bool nextFrameIndependentlyTasked() const;


    virtual void setNextFrameGlobalId(const DtString&);


    virtual void setNextFrameEntityId(const DtEntityIdentifier& id);

    virtual DtEntityIdentifier nextFrameEntityId() const;


    virtual bool setNextFrameObjectName(const DtString&);

    virtual DtString nextFrameObjectName() const;


    virtual void setNextFrameObjectType(const DtObjectType&);

    virtual DtObjectType nextFrameObjectType() const;


    void setNotifyLevel(int);

    DtSimulationServices* simulationServices() const;


    bool converting() const

    {

       return myConverting;

    }


    template <typename T_Component>

    T_Component* addStateComponent(bool checkWritable = false, bool isRemote = false)

    {

       if (isValid())

       {

          T_Component* comp = myExternalNextFrameState->addStateComponent<T_Component>(checkWritable, isRemote);


          if (comp)

          {

             makVrf::DtStateData* sd = const_cast<DtSimulationServices*>(mySimulationServices)->stateDataManager()->stateDataFor(myUUID);


             if (sd)

             {

                makVrf::DtStateComponent* stateComponent = sd->getStateComponent<T_Component>(comp->id());


                if (stateComponent)

                {

                   stateComponent->setIsRemoteComponent(false);

                }

             }

          }


          return comp;

       }

       else

       {

          throw makVrf::DtUnimplementedMethod("The addStateComponent is not implemented for this class.");

       }

    }


    makVrf::DtFrameStateInterface* addStateComponent(makVrf::DtStateComponent::StateComponentType t);


    virtual bool nextFrameIsEmbarked() const;

    virtual DtUUID nextFrameEmbarkedOn() const;

    virtual void setNextFrameEmbarkedOn(const DtUUID& u);

    virtual bool nextFrameIsEmbarkedOn(const DtUUID&) const;

    virtual DtSimObjectReference nextFrameSimObjectEmbarkedOn() const;


    virtual void setNextFrameEchelonId(const DtEchelonId&);

    virtual DtEchelonId nextFrameEchelonId() const;


    virtual void setNextFrameForceType(int);

    virtual DtForceType nextFrameForceType() const;


    virtual void setNextFrameSessionId(int);

    virtual int nextFrameSessionId() const;


    virtual void setNextFrameVrfMessageVersionSupported(int);

    virtual int nextFrameVrfMessageVersionSupported() const;


    virtual void removeNextFrameExtendedData(const DtString&);


    void removeStateComponent(const makVrf::DtFrameStateInterface*);


    virtual void upgradeFromImport();


    makVrf::DtTaskVisualizationStateComponent* lineTaskVisualization(const DtString& visualName, const DtString& component);

    makVrf::DtTaskVisualizationStateComponent* pointTaskVisualization(const DtString& visualName, const DtString& component);

    makVrf::DtTaskVisualizationStateComponent* areaTaskVisualization(const DtString& visualName, const DtString& component);

    makVrf::DtTaskVisualizationStateComponent* textTaskVisualization(const DtString& visualName, const DtString& component);

    void removeTaskVisualization(makVrf::DtTaskVisualizationStateComponent*);


    makVrf::DtLaserDesignatorStateComponent* addLaserDesignator();

    void removeLaserDesignator(makVrf::DtLaserDesignatorStateComponent*);


    makVrf::DtEmitterSystemStateComponent* addEmitterSystem();

    void removeEmitterSystem(makVrf::DtEmitterSystemStateComponent*);


    makVrf::DtActiveSonarStateComponent* addActiveSonarSystem();

    void removeActiveSonarSystem(makVrf::DtActiveSonarStateComponent*);


    makVrf::DtRadioTransmitterStateComponent* addRadioTransmitter();

    void removeRadioTransmitter(makVrf::DtRadioTransmitterStateComponent*);


    makVrf::DtNavAidRadioTransmitterStateComponent* addNavAidRadioTransmitter();

    void removeNavAidRadioTransmitter(makVrf::DtNavAidRadioTransmitterStateComponent*);


    makVrf::DtRadioReceiverStateComponent* addRadioReceiver();

    void removeRadioReceiver(makVrf::DtRadioReceiverStateComponent*);


    makVrf::DtIffStateComponent* getOrCreateIffSystem();

    void removeIffSystem();


    makVrf::DtUnderwaterAcousticsStateComponent* getOrCreateUnderwaterAcousticsSystem(bool isRemote = false);

    void removeUnderwaterAcousticsSystem();


    virtual void setNextFrameUnderFire(bool b);

    virtual bool nextFrameUnderFire() const;

    virtual void setNextFrameInvulnerable(bool);

    virtual bool nextFrameInvulnerable() const;


    virtual void setNextFrameUndetectable(bool);

    virtual bool nextFrameUndetectable() const;


    virtual void setNextFrameHalfLengthWidthHeight(double length, double width, double height);

    virtual void setNextFrameObjectGeometry(const makVrf::DtVrfObjectGeometry&);

    virtual void setNextFrameBoundingGeometryType(DtSimBoundingGeometry::DtSimBoundingGeometryType type);

    virtual void setNextFrameBoundingVolume(const Dt3dBoundingVolume& b);


    virtual void setNextFrameHasPlan(bool);

    virtual bool nextFrameHasPlan() const;


    virtual void setNextFrameExecutingPlan(bool);

    virtual bool nextFrameExecutingPlan() const;


    virtual void setNextFrameOccupantsHidden(bool);

    virtual bool nextFrameOccupantsHidden() const;


    virtual std::map<DtString, DtString> nextFrameExtendedDataMap() const;


    virtual std::map<int, DtString> nextFrameExtendedLabels() const;


    virtual bool nextFrameIsOnTopOf(const DtSimObject* o, bool checkSupportPoints = false) const;

    virtual bool nextFrameIsOnTopOf(const DtSimObject* o, double d, bool checkSupportPoints = false) const;


    DtLocalObjectDecorator* getOrCreateDecorator(const std::string& Decorator);


    void setLocationComplete();


    boost::signals2::signal<void ()> signal_preUpgradeFromImport;


    boost::signals2::signal<void ()> signal_postUpgradeFromImport;


    boost::signals2::signal<void ()> signal_objectInitialized;


    boost::signals2::signal<void ()> signal_objectRestored;


    boost::signals2::signal <void (DtLocalObject*)> signal_objectModifiedViaMessage;


    boost::signals2::signal <void (DtLocalObject*)> signal_newSensorContact;


    boost::signals2::signal <void (DtLocalObject*)> signal_navigationAreaChanged;


    boost::signals2::signal <void (DtLocalObject*)> signal_setLocationComplete;


    boost::signals2::signal<void ()> signal_restored;


    mutable boost::signals2::signal<void (const DtLocalObject*, ChangeFlag)> signal_objectDataChanged;


    boost::signals2::signal<void(const DtLocalObject*)> signal_localObjectAboutToBeDeleted;


    virtual void setNextFrameParameterProperties(const DtRwProperties&);

    const DtRwProperties& nextFrameParameterProperties() const;


    virtual const DtRwProperties& nextFrameStateProperties() const;

    virtual const DtRwProperties& stateProperties() const;

    virtual void setNextFrameStateProperties(const DtRwProperties&);


    virtual bool nextFrameFuelLevelsFrozen() const;


    virtual bool nextFrameMunitionLevelsFrozen() const;


    virtual void setSimulationCapable(bool);

    bool simulationCapable() const;


    virtual void setNextFrameBlockParachute(bool);

    virtual bool nextFrameBlockParachute() const;


    virtual void setNextFrameOnTerrainSurface(bool b);

    virtual bool nextFrameOnTerrainSurface() const;


    virtual void setOperationInProgress(int, bool);

    virtual bool operationInProgress(int) const;

    virtual void clearOperationsInProgress();


 public:


    virtual bool createInternalState(const DtVrfObjectParameters* parameterEntry);


    virtual bool setupSubComponentTypes();


    virtual bool init();


    virtual bool create();


    static DtLocalObjectCreatorFcn setLocalObjectCreatorFunction(DtLocalObjectCreatorFcn);

    static DtLocalObjectCreatorFcn localObjectCreatorFunction();

    static DtLocalObject* create(DtSimulationServices*, const DtVrfLocalObjectCreateInformation&);


    static DtLocalObject* createAndInit(DtSimulationServices*, const DtVrfLocalObjectCreateInformation&);


    static void readDRThresholdSettingsCallback(

       const DtSettingsObject* settings, void* usr);

    virtual void processReadDRThresholdSettings(const DtSettingsObject* settings);


    bool isGlobalPlan() const;


    bool isSyncMatrix() const;


    virtual int publicationFlag() const;


    virtual bool isCapableOfTask(std::string taskName);


 public:


    static void enableSingleObjectMode();

    static bool singleObjectModeActive();


    virtual bool convertToRemoteObject(DtString& error);

    virtual bool convertToLocalObject(DtString& error, const std::string& archiveState);

    boost::signals2::signal<void (DtLocalObject*, DtVrfObjectHandoffData::HandoffFlag)> signal_handoffStep;


    virtual bool prepareForHandoff();

    boost::signals2::signal<void (DtLocalObject*, DtVrfObjectHandoffData&)> signal_prepareForHandoff;


    virtual std::string archiveState() const;


 public:

    typedef std::list<DtLuaScriptInterfaceExtension::CreatorUserPair> ScriptInterfaceExtensions;


    const DtObjectResourceManager* objectResourceManager() const;

    DtObjectResourceManager* objectResourceManager();


    virtual DtVrfObjectStateRepository* internalState();

    virtual const DtVrfObjectStateRepository* internalState() const;


    virtual void prepareForReinitialization();


    DtVrfObjectSubComponentTypes* vrfSubComponentTypes() const;


    virtual void tick();


    virtual void startTick();

    virtual void tickComponents();

    virtual void endTick();


    virtual int scenarioRunId() const;


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


    virtual bool checkAndDisembarkIfEmbarked(const DtVector& localPosition);

    virtual bool lowFidelityDisembarkHitCheck(const DtVector& localPosition) const;

    virtual bool highFidelityDisembarkHitCheck(const DtVector& localPosition) const;


    virtual int nextEmitterSystemId();


 public:

    virtual DtVrfObjectCommunicationInterface* communicationInterface();

    virtual const DtVrfObjectCommunicationInterface* communicationInterface() const;

    virtual DtVrfObjectTerrainPreloadManager* terrainPreloadManager();

    virtual DtSimRadio* radio() const;

    virtual DtSimTaskManager* taskManager() const;

    virtual DtScriptInterfaceHandler* scriptInterfaceHandler() const;

    virtual DtVrfObjectPlanManager* vrfObjectPlanManager() const;

    virtual DtSimComponentManager* componentManager();

    virtual const DtSimComponentManager* componentManager() const;


    virtual DtSetDataManager* setDataManager();

    virtual const DtSetDataManager* setDataManager() const;


    bool initialized() const

    {

       return myInitialized;

    }


    DtVrfCallbackQueue::CallbackInterface::Ptr parallelContainer()

    {

       if (!myParallelContainer)

       {

          myParallelContainer = DtVrfCallbackQueue::CallbackInterface::Ptr(new SimObjectCallback(this));

       }


       return myParallelContainer;

    }


 public:

    virtual void cleanupItemsNeededForHandoff();

    virtual bool recreateItemsNeededFromHandoff();


 protected:

    static void logToFileCallback(const DtVrfObjectMessage* msg, void* usr);

    virtual void processLogToFile(const DtVrfObjectMessage* msg);


    static void stopLoggingToFileCallback(const DtVrfObjectMessage* msg, void* usr);

    virtual void processStopLoggingToFile(const DtVrfObjectMessage* msg);


    virtual void createNavigationDecorator() override;


    class SimObjectCallback : public DtVrfCallbackQueue::CallbackInterface

    {

    public:

       typedef std::vector<SimObjectCallback> Vector;


       DtLocalObject* object;

       bool parallelTick;


       explicit SimObjectCallback(DtLocalObject* obj)

          : object(obj) { }


       void run() override;

    };


 public:


    virtual void addScriptExtension(DtLuaScriptInterfaceExtension::CreatorFcn extension, void* usr);

    virtual void removeScriptExtension(DtLuaScriptInterfaceExtension::CreatorFcn extension, void* usr);

    virtual const ScriptInterfaceExtensions& scriptExtensions() const;


    virtual void setupFromMessageContent(const DtIfModifyVrfObject* ifModVrfObject);

    virtual bool validNameLength(const DtString& name) const;


    static bool shouldArchiveExtendedAttribute(const DtString& s);

    static void doNotArchiveAttribute(const DtString& s, bool b);


    virtual void sendVrfObjectCreated(unsigned long requestId = 0, bool requestCreated = true);


    virtual void setIsInMovementFlux(bool, const DtVector& proposedLocation = DtVector::zero());


    boost::signals2::signal<void (DtLocalObject*)> signal_postInitFromParams;


 protected:

    virtual void setupStateRepository();

    virtual void internalStateInitializedFromParameters();


    virtual bool createCommunicationsInterface();

    virtual void initializeCommunicationInterfaceCallbacks();

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

    virtual void processSetOverlayLayerTask(const DtVrfObjectMessage* msg);


    virtual bool createScriptInterfaceHandler();


    virtual bool createComponentManager();


    virtual bool initializeComponentManager();


    virtual bool createRadio();

    virtual bool createVrfObjectPlanManager();

    virtual bool createSetDataManager();


    virtual void tickDecorators();


    void createRemotelyControlledLocalObject();

    virtual void completeSetup() override;


 protected:

    virtual bool createTaskManager();


    virtual void createCommunicationsInterface(const DtRadioDescriptorList& descList);


    virtual void updateEntityHasTarget();


 protected:

    void setUUID(const DtUUID&) override;


    virtual void convertedToRemote();


    virtual std::map<DtString, DtString> unarchivedData();


    virtual void clearDecorators() override;


    virtual void usingParameterSource(const DtString&) override;


    virtual void setupVrfObjectParameters() override;


    void cacheNextFrameComponents();

    void clearNextFrameCachedComponents();


    virtual void hostChanged(const DtUUID& oldHost, const DtUUID& newHost) override;


    virtual void isClutterChanged() override;


    friend class DtVrfObjectStateRepository;

    virtual void setupExtendedDataFromParameterData();


    virtual bool canBePlaced() const;


 protected:

    DtLocalObject(const DtLocalObject& orig);


    DtLocalObject& operator=(const DtLocalObject& orig);


 protected:

    DtVrfObjectStateRepository*         myInternalState;

    DtVrfObjectSubComponentTypes*       mySubComponentTypes;

    makVrf::DtExternalNextFrameState*   myExternalNextFrameState;

    DtVrfObjectCommunicationInterface*  myCommunicationInterface;

    DtVrfObjectTerrainPreloadManager*   myTerrainPreloadManager;

    DtSimRadio*                         myRadio;

    DtSimTaskManager*                   myTaskManager;

    DtScriptInterfaceHandler*           myScriptInterfaceHandler;

    DtSimComponentManager*              myComponentManager;

    DtVrfObjectPlanManager*             myVrfObjectPlanManager;

    DtSetDataManager*                   mySetDataManager;


    bool myCreatedStateData;


    typedef std::map<std::string, DtLocalObjectDecorator*> LocalObjectDecorators;

    LocalObjectDecorators myLocalObjectDecorators;


    boost::signals2::scoped_connection myConvertedToRemoteConnection;

    static DtLocalObjectCreatorFcn theLocalObjectCreatorFunction;


    DtVrfLocalObjectCreateInformation* myLocalObjectCreateInformation;


    bool myInitializing;

    bool myInitialized;

    int myNextEmitterSystemId;

    static std::set<DtString> theDoNotArchiveAttributes;


    DtAppearanceLocalObjectFacade* myAppearanceLocalObjectFacade;


    ScriptInterfaceExtensions myScriptInterfaceExtensions;


    bool myConverting;


    bool mySimulationCapable;


    bool myHasTarget;

    bool myControllersTicked;

    bool mySkipNextComponentTick;

    bool mySignalLocationComplete;

    bool myIsEnvironmental = false;


    mutable DtRwProperties* myDefaultStateProperties;


    makVrf::DtLocationStateComponent* myNextFrameLocationStateComponent;

    makVrf::DtSimulatedObjectStateComponent* myNextFrameSimulatedObjectStateComponent;

    makVrf::DtVrfGeometryStateComponent* myNextFrameVrfGeometryStateComponent;

    makVrf::DtVrfStateComponent* myNextFrameVrfStateComponent;

    makVrf::DtStatePropertiesStateComponent* myNextFrameStatePropertiesStateComponent;

    const makVrf::DtStatePropertiesStateComponent* myCurrentFrameStatePropertiesStateComponent;


    DtSimObjectReference myNextFrameSimObjectEmbarkedOn;


    DtMovementLocalObjectFacade* myMovementLocalObjectFacade;


    typedef std::map<int, int> OperationsInProgressCount;

    OperationsInProgressCount myOperationsInProgressCount;


    int myFluxIndex = -1;


    DtVrfCallbackQueue::CallbackInterface::Ptr myParallelContainer;


 public:

    VRF4API_METHOD DtVrfObjectStateRepository* vrfState() { return internalState(); };

    VRF4API_METHOD const DtVrfObjectStateRepository* vrfState() const { return internalState(); };

    VRF4API_METHOD void setObjectIdentifier(const DtEntityIdentifier& id) { setNextFrameEntityId(id); };

    VRF4API_METHOD void place(const DtReal heading, bool* dataAvailable = 0,

       bool requireAllData = false);

    VRF4API_METHOD void place(const DtVector& heading, bool* dataAvailable = 0,

       bool requireAllData = false);

    VRF4API_METHOD bool isVrfSimulated() const { return nextFrameIsVrfSimulated(); };

    VRF4API_METHOD void invokeSetLocationCompleteCallbacks() { return setLocationComplete(); };

 };

DtUUID
UUID is a unique ID wrapper class.
Definition: uuid.h:59

DtVrfObjectParameters
Instances of DtVrfObjectParameters are the readable/writeable objects that contain the information ne...
Definition: vrfObjectParameters.h:63

DtLocalObject::signal_objectInitialized
boost::signals2::signal< void()> signal_objectInitialized
Signal sent at the very end of the init() method.
Definition: localObject.h:492

DtScriptInterfaceHandler
Definition: scriptInterfaceHandler.h:19

DtLocalObject::invokeSetLocationCompleteCallbacks
VRF4API_METHOD void invokeSetLocationCompleteCallbacks()
These are backwards compatible methods that can be used if you define ALLOW_VRF4API in your header fi...
Definition: localObject.h:949

DtLocalObject::getNextFrameStateComponent
T_Component * getNextFrameStateComponent()
General call to get any component that does not have a method.
Definition: localObject.h:113

DtVrfObjectHandoffData::Abort
Definition: localObject.h:72

makVrf::DtStatePropertiesStateComponent
1) Define the interface class that will be used to represent the next and curent frames. The UNDEFINED_ macros are convenience macros that will define methods that throw exceptions (until they are implemented)
Definition: statePropertiesStateComponent.h:93

DtVrfObjectStateRepository::setupExtendedDataFromParameterData
virtual VRF4API_METHOD void setupExtendedDataFromParameterData()
If publishing parameter data also include that in the extended data map by name.

makVrf::DtUnimplementedMethod
Definition: stateDataTypes.h:23

DtAttachedTerrain
Definition: attachedTerrain.h:46

vrfCallbackQueue.h

DtSimObject::getOrCreateDecorator
DtSimObjectDecorator * getOrCreateDecorator(const std::string &Decorator) const
This will get or create a decorator based on the decorator name. This is not virtual such that the Dt...

DtLocalObject::myOperationsInProgressCount
OperationsInProgressCount myOperationsInProgressCount
Definition: localObject.h:930

DtLocalObject::signal_objectDataChanged
boost::signals2::signal< void(const DtLocalObject *, ChangeFlag)> signal_objectDataChanged
Signal sent when certain data has changed in this class from being set by the API, not from the network.
Definition: localObject.h:513

DtSimObject::setUUID
virtual void setUUID(const DtUUID &)

DtLocalObject::myCreatedStateData
bool myCreatedStateData
Definition: localObject.h:881

DtLocalObject::converting
bool converting() const
Definition: localObject.h:342

DtLocalObject::myNextFrameVrfStateComponent
makVrf::DtVrfStateComponent * myNextFrameVrfStateComponent
Definition: localObject.h:921

DtLocalObject::myInitializing
bool myInitializing
Definition: localObject.h:895

DtSimObject::operator=
DtSimObject & operator=(const DtUUID &)

DtSimObject::mySimulationServices
const DtSimulationServices * mySimulationServices
Definition: simObject.h:500

makVrf::DtRadioTransmitterStateComponent
1) Define the interface class that will be used to represent the next and curent frames. The UNDEFINED_ macros are convenience macros that will define methods that throw exceptions (until they are implemented)
Definition: radioTransmitterStateComponent.h:139

DtLocalObject::signal_restored
boost::signals2::signal< void()> signal_restored
Signal emitted when the object has been restored.
Definition: localObject.h:510

DtLocalObject::OperationsInProgressCount
std::map< int, int > OperationsInProgressCount
Definition: localObject.h:929

DtLocalObject::vrfState
VRF4API_METHOD const DtVrfObjectStateRepository * vrfState() const
These are backwards compatible methods that can be used if you define ALLOW_VRF4API in your header fi...
Definition: localObject.h:942

DtLocalObject::ChangeFlag
ChangeFlag
Definition: localObject.h:95

makVrf::DtLocationStateComponent
The DtLocationStateComponent interface contains the interface that all DtLocationStateComponents can ...
Definition: locationStateComponent.h:25

DtLocalObject::signal_postUpgradeFromImport
boost::signals2::signal< void()> signal_postUpgradeFromImport
Signal sent when upgrading from import. This will be called after any internal routines are called...
Definition: localObject.h:489

makVrf::DtStateComponent::setIsRemoteComponent
virtual void setIsRemoteComponent(bool b)
Definition: stateComponent.h:133

DtLocalObject::SimObjectCallback::parallelTick
bool parallelTick
Definition: localObject.h:751

DtSimRadio
Definition: simRadio.h:30

makVrf::DtStateComponent::StateComponentType
unsigned int StateComponentType
Definition: stateComponent.h:55

DtLocalObject::mySimulationCapable
bool mySimulationCapable
Whether or not this object is capable of simulating. Default is true.
Definition: localObject.h:908

DtLocalObject::myTerrainPreloadManager
DtVrfObjectTerrainPreloadManager * myTerrainPreloadManager
Definition: localObject.h:873

DtLocalObject::myNextFrameSimObjectEmbarkedOn
DtSimObjectReference myNextFrameSimObjectEmbarkedOn
Definition: localObject.h:925

DtLocalObject::ForceType
Definition: localObject.h:98

DtSimObject::tickDecorators
void tickDecorators()

noArgumentCallbackList.h

DtSimObject::isValid
bool isValid() const
Returns true if myExternalCurrentFrameState is not nullptr. Not virtual on purpose as even though loc...

makVrf::DtSimulatedObjectStateComponent
The DtSimulatedObjectStateComponent is an interface that all main components (those that are consider...
Definition: simulatedObjectStateComponent.h:21

DtLocalObject::mySetDataManager
DtSetDataManager * mySetDataManager
Definition: localObject.h:879

DtSimObjectStateRepository::heading
VRF4API_METHOD DtReal heading() const
Heading in radians.

DtLocalObject::signal_objectModifiedViaMessage
boost::signals2::signal< void(DtLocalObject *)> signal_objectModifiedViaMessage
Signal sent when this object is modified via a message.
Definition: localObject.h:498

DtLocalObject::myComponentManager
DtSimComponentManager * myComponentManager
Definition: localObject.h:877

DtSimObject::clearDecorators
virtual void clearDecorators()
This code will keep track of DtSimObject decorator only. The DtLocalObject will be able to use this d...

DtLocalObject::ObjectLabel
Definition: localObject.h:99

DtLocalObject::addStateComponent
T_Component * addStateComponent(bool checkWritable=false, bool isRemote=false)
Adds the given state component by its intrinsic type.
Definition: localObject.h:349

DtLocalObject::myLocalObjectDecorators
LocalObjectDecorators myLocalObjectDecorators
Decorator members.
Definition: localObject.h:886

DtSimObjectReference
The DtSimObjectReference is a shared pointer that can be used amongst many object for access to the u...
Definition: simObjectReference.h:26

DtSimObject::createNavigationDecorator
virtual void createNavigationDecorator()

DtVrfObjectHandoffData::Failed
Failure to recreate object for local usage so must be deleted.
Definition: localObject.h:73

DtLocalObject::myDefaultStateProperties
DtRwProperties * myDefaultStateProperties
Definition: localObject.h:916

DtLocalObject::signal_postInitFromParams
boost::signals2::signal< void(DtLocalObject *)> signal_postInitFromParams
Signal sent right after the internal state is initialized from parameters.
Definition: localObject.h:788

DtSimObjectStateRepository
Definition: simObjectStateRepository.h:59

DtVrfObjectHandoffData::AfterConvertToRemote
Definition: localObject.h:69

makVrf::DtExternalNextFrameState
Definition: stateData.h:116

DtLocalObject::myHasTarget
bool myHasTarget
Definition: localObject.h:910

DtVrfLocalObjectCreateInformation
The DtLocalObjectCreateInformation class is a subset of the information used in the DtIfCreateVrfObje...
Definition: vrfLocalObjectCreateInformation.h:26

DtVrfObjectStateRepository
Description: This repository is an internal repository accessible only by local objects. It holds all information that is common to all the forms of all entity/aggregate/control objects within VR-Forces.
Definition: vrfObjectStateRepository.h:91

DtLocalObject::getNextFrameStateComponent
const T_Component * getNextFrameStateComponent() const
General call to get any component that does not have a method.
Definition: localObject.h:120

DtSimObject::isClutterChanged
virtual void isClutterChanged()

DtLocalObject::myRadio
DtSimRadio * myRadio
Definition: localObject.h:874

DtSettingsObject
Definition: settingsObject.h:27

makVrf::DtVrfGeometryStateComponent
1) Define the interface class that will be used to represent the next and curent frames. The UNDEFINED_ macros are convenience macros that will define methods that throw exceptions (until they are implemented)
Definition: vrfGeometryStateComponent.h:54

appearanceLocalObjectFacade.h

DtLocalObject::signal_newSensorContact
boost::signals2::signal< void(DtLocalObject *)> signal_newSensorContact
Signal made available from this object to be used when a new sensor contact is made available for thi...
Definition: localObject.h:501

DtIfModifyVrfObject
class DtIfModifyVrfObject:
Definition: ifModifyVrfObject.h:50

DtObjectType
Definition: objectType.h:27

DtLocalObject::myConvertedToRemoteConnection
boost::signals2::scoped_connection myConvertedToRemoteConnection
Definition: localObject.h:889

DtLocalObject::SimObjectCallback::object
DtLocalObject * object
Definition: localObject.h:750

DtSimObject::simulationServices
const DtSimulationServices * simulationServices() const
Definition: simObject.h:273

DtRadioDescriptorList
List of DtRadioDescriptor subclasses that can be read from a RW type file. This class owns all descri...
Definition: radioDescriptorList.h:27

DtLocalObject::myCurrentFrameStatePropertiesStateComponent
const makVrf::DtStatePropertiesStateComponent * myCurrentFrameStatePropertiesStateComponent
Definition: localObject.h:923

DtLocalObject::myNextEmitterSystemId
int myNextEmitterSystemId
Definition: localObject.h:897

echelonId.h

DtLocalObject::setObjectIdentifier
VRF4API_METHOD void setObjectIdentifier(const DtEntityIdentifier &id)
These are backwards compatible methods that can be used if you define ALLOW_VRF4API in your header fi...
Definition: localObject.h:943

DtVector

DtLocalObject::signal_localObjectAboutToBeDeleted
boost::signals2::signal< void(const DtLocalObject *)> signal_localObjectAboutToBeDeleted
Signal sent when a local object is about to be deleted.
Definition: localObject.h:516

DtLocalObject::myExternalNextFrameState
makVrf::DtExternalNextFrameState * myExternalNextFrameState
Definition: localObject.h:871

DtVrfObjectSubComponentTypes
DtVrfObjectSubComponentTypes.
Definition: vrfObjectSubComponentTypes.h:25

makVrf::DtVrfStateComponent
1) Define the interface class that will be used to represent the next and curent frames. The UNDEFINED_ macros are convenience macros that will define methods that throw exceptions (until they are implemented)
Definition: vrfStateComponent.h:62

makVrf::DtStateData::getStateComponent
DtStateComponent * getStateComponent(int index=0)
Definition: stateData.h:542

DtSimObject::hostChanged
virtual void hostChanged(const DtUUID &oldHost, const DtUUID &newHost)

DtObjectConsole
This class represents the console for an individual object. It owns a set of streams for various noti...
Definition: objectConsole.h:49

DtSimObject::completeSetup
virtual void completeSetup()

DtLocalObject::LocalObjectDecorators
std::map< std::string, DtLocalObjectDecorator * > LocalObjectDecorators
Decorator members.
Definition: localObject.h:885

makVrf::DtStateData
The overall structure of the DtStateData mechanism is: The DtStateData contains a list of double buff...
Definition: stateData.h:339

DtLocalObject::signal_setLocationComplete
boost::signals2::signal< void(DtLocalObject *)> signal_setLocationComplete
Signal sent when the location has been changed by an interface content message.
Definition: localObject.h:507

DtVrfCallbackQueue::CallbackInterface
API for writing callbacks.
Definition: vrfCallbackQueue.h:58

makVrf::DtLaserDesignatorStateComponent
1) Define the interface class that will be used to represent the next and curent frames. The UNDEFINED_ macros are convenience macros that will define methods that throw exceptions (until they are implemented)
Definition: laserDesignatorStateComponent.h:56

DT_DLL_vrfobjcore
#define DT_DLL_vrfobjcore
This file is used to determine how to build.
Definition: vrfobjcoreDefines.h:24

DtLocalObject::signal_objectRestored
boost::signals2::signal< void()> signal_objectRestored
Signal sent after the object has been restored from the stream.
Definition: localObject.h:495

movementLocalObjectFacade.h

DtLocalObject::myConverting
bool myConverting
Will be true if this object is in the process of converting from remote to local. ...
Definition: localObject.h:905

DtSimObject::usingParameterSource
virtual void usingParameterSource(const DtString &)
Called when the parameter is set up, this is the source it is using.

DtLocalObject::SimObjectCallback::SimObjectCallback
SimObjectCallback(DtLocalObject *obj)
Definition: localObject.h:753

DtVrfObjectHandoffData::HandoffFlag
HandoffFlag
Definition: localObject.h:63

makVrf::DtActiveSonarStateComponent
1) Define the interface class that will be used to represent the next and curent frames. The UNDEFINED_ macros are convenience macros that will define methods that throw exceptions (until they are implemented)
Definition: activeSonarStateComponent.h:286

DtSimObject::setupVrfObjectParameters
virtual void setupVrfObjectParameters()

DtLocalObject::ScriptInterfaceExtensions
std::list< DtLuaScriptInterfaceExtension::CreatorUserPair > ScriptInterfaceExtensions
Definition: localObject.h:637

DtLocalObject::myTaskManager
DtSimTaskManager * myTaskManager
Definition: localObject.h:875

DtLocalObjectFacade
If inheriting from a base sim object proxy.
Definition: localObjectFacadeBase.h:32

DtVertexList
class DtVertexList:
Definition: vertexList.h:22

radioTransmitterStateComponent.h

DtLocalObject::myParallelContainer
DtVrfCallbackQueue::CallbackInterface::Ptr myParallelContainer
Definition: localObject.h:936

DtLocalObject::SimObjectCallback::Vector
std::vector< SimObjectCallback > Vector
Definition: localObject.h:748

DtVrfObjectHandoffData::BeforeConvertToRemote
Definition: localObject.h:68

DtLocalObject::ObjectType
Definition: localObject.h:101

DtLocalObject::myNextFrameSimulatedObjectStateComponent
makVrf::DtSimulatedObjectStateComponent * myNextFrameSimulatedObjectStateComponent
Definition: localObject.h:919

DtLocalObject::signal_handoffStep
boost::signals2::signal< void(DtLocalObject *, DtVrfObjectHandoffData::HandoffFlag)> signal_handoffStep
Signal sent with object handoff flags for this object given the handoff state.
Definition: localObject.h:627

DtLocalObject::myNextFrameLocationStateComponent
makVrf::DtLocationStateComponent * myNextFrameLocationStateComponent
Only set if there is no state properties state component.
Definition: localObject.h:918

DtLocalObject::myMovementLocalObjectFacade
DtMovementLocalObjectFacade * myMovementLocalObjectFacade
Definition: localObject.h:927

DtSimBoundingGeometry::DtSimBoundingGeometryType
DtSimBoundingGeometryType
Definition: simBoundingGeometry.h:61

DtSimObject::makeInvalid
virtual void makeInvalid()
Make this invalid by clearing the myExternalCurrentFrameState. This will also set the myIsDeleted fla...

DtLocalObject::theLocalObjectCreatorFunction
static DtLocalObjectCreatorFcn theLocalObjectCreatorFunction
Definition: localObject.h:890

DtVrfObjectMessage
The base class for all messages to/from a specific DtVrfObject. Various subclasses of this class will...
Definition: vrfObjectMessage.h:30

DtLocalObject::getNextFrameStateComponentList
const std::vector< T_Component * > getNextFrameStateComponentList() const
General call to get any component that does not have a method.
Definition: localObject.h:134

DtObjectResourceManager
This is the top-level resource manager for a DtLocalObject. The actual resources are stored in DtSimR...
Definition: objectResourceManager.h:21

makVrf::DtVrfObjectGeometry
This class maintains a rectangular bounding volume and an ordered list of vertices describing the phy...
Definition: vrfObjectGeometry.h:39

DtLocalObject::myInitialized
bool myInitialized
Definition: localObject.h:896

error
Definition: asyncJobServer.h:39

vrf4XAPI.h

DtVrfObjectPlanManager
class DtVrfObjectPlanManager:
Definition: vrfObjectPlanManager.h:38

makVrf::DtEmitterSystemStateComponent
1) Define the interface class that will be used to represent the next and curent frames. The UNDEFINED_ macros are convenience macros that will define methods that throw exceptions (until they are implemented)
Definition: emitterSystemStateComponent.h:466

DtEchelonId
Definition: echelonId.h:13

DtLocalObject::SimObjectCallback
Definition: localObject.h:745

DtVrfObjectStateRepository::place
virtual void place(const DtVector &location, bool *dataAvailable=nullptr, bool requireAllData=false)
Place entity at &#39;location&#39;, on the ground, keeping its current heading. Since no terrain intersection...

makVrf::DtStateComponent
Definition: stateComponent.h:51

DtVrfObjectTerrainPreloadManager
This manager is on a per-DtLocalObject level, and is responsible for knowing what terrain areas an ob...
Definition: vrfObjectTerrainPreloadManager.h:36

DtSimTaskManager
Class Description: DtSimTaskManager manages the bookkeeping associated with starting, completing, clearing, and skipping tasks.
Definition: simTaskManager.h:52

simulationServices.h

DtLocalObject::myNextFrameStatePropertiesStateComponent
makVrf::DtStatePropertiesStateComponent * myNextFrameStatePropertiesStateComponent
Definition: localObject.h:922

makVrf::DtRadioReceiverStateComponent
1) Define the interface class that will be used to represent the next and curent frames. The UNDEFINED_ macros are convenience macros that will define methods that throw exceptions (until they are implemented)
Definition: radioReceiverStateComponent.h:64

DtSimComponentManager
The DtSimComponentManager is the top level class within a DtSimObject which owns and manages all the ...
Definition: simComponentManager.h:30

DtLuaScriptInterfaceExtension::CreatorFcn
DtLuaScriptInterfaceExtension *(* CreatorFcn)(void *usr)
Prototype for DtLuaScriptInterfaceExtension creator function.
Definition: luaScriptInterfaceExtension.h:37

DtSimulationServices
Central access point of all non-object-specific the services and managers that are available for use ...
Definition: simulationServices.h:94

DtVrfObjectHandoffData::BeforeConvertToLocal
Definition: localObject.h:70

DtLocalObject::myInternalState
DtVrfObjectStateRepository * myInternalState
Definition: localObject.h:869

DtSimObject
Represents a single simulation object in the exercise. Object may be VRF simulation, or non-VRF simulated, and may be simulated by the local sim engine, or by a remote sim engine. Only public (external) state of the object is available. All data is read-only. All access to data of the object is thread safe within the simulation frame.
Definition: simObject.h:88

DtVrfObjectCommunicationInterface
The central class of a DtLocalObject for all communications to and from the object. This class manages all communications on a specific DtLocalObject, though both simulation internal communication, and communication though the simulated radios of the object. All communication is done though the use of the DtVrfObjectMessage class and its subclasses. Callbacks can be registered on this interface which will be called on receipt of a message by this entity. Messages can be sent from this entity by using the message sending functions. These messages may be sent though the SimInternal message mechanism, or the radio message system. Radios will not exist until createRadiosFromDescriptorList() or createRadiosFromDescriptorList(const DtRadioDescriptorList&amp; descList) is called.
Definition: vrfObjectCommunicationInterface.h:40

DtVrfObjectHandoffData::AfterConvertToLocal
Definition: localObject.h:71

DtSetDataManager
This class manages the distribution of DtSetDataRequests within a single DtLocalObject. Components of the object, or other parts of the code, register interested in particular types of set data messages and when such a message is processed by the DtSetDataManager, each of the registered parties is notified.
Definition: setDataManager.h:48

DtLocalObject::initialized
bool initialized() const
Definition: localObject.h:711

DtLocalObject::myScriptInterfaceHandler
DtScriptInterfaceHandler * myScriptInterfaceHandler
Definition: localObject.h:876

makVrf::DtNavAidRadioTransmitterStateComponent
1) Define the interface class that will be used to represent the next and curent frames. The UNDEFINED_ macros are convenience macros that will define methods that throw exceptions (until they are implemented)
Definition: navAidRadioTransmitterStateComponent.h:20

makVrv::vrvTacticalGraphicUtilities::length
DT_DLL_VRVCORE double length(const makVrv::DtCoordinateSystem &, const std::vector< DtVector > &vertices)
Returns the total distance of a segmented line defined by the provided vector of vertices. Coordinates are in local database coordinates. The coordinate system is used to convert between the local database coordinates and geocentric. All distance is in 2D – the Z value is ignored.

luaScriptInterfaceExtension.h
DtLuaScriptInterfaceExtension.

DtVrfObjectHandoffData::handoffFlag
HandoffFlag handoffFlag
Definition: localObject.h:76

init
DT_DLL_DEBUGDRAWRENDERER void init(makVrv::DtDe &de)
Work function for the plugin initialization.

DtLocalObject::signal_navigationAreaChanged
boost::signals2::signal< void(DtLocalObject *)> signal_navigationAreaChanged
Signal made available from this object to be used when the navigation area this object is in has chan...
Definition: localObject.h:504

DtLocalObject::myNextFrameVrfGeometryStateComponent
makVrf::DtVrfGeometryStateComponent * myNextFrameVrfGeometryStateComponent
Definition: localObject.h:920

DtLocalObjectCreatorFcn
DtLocalObject *(* DtLocalObjectCreatorFcn)(DtSimulationServices *, const DtVrfLocalObjectCreateInformation &)
Definition: localObject.h:59

DtLocalObject::mySignalLocationComplete
bool mySignalLocationComplete
Definition: localObject.h:913

DtLocalObject::parallelContainer
DtVrfCallbackQueue::CallbackInterface::Ptr parallelContainer()
Definition: localObject.h:716

makVrf::DtUnderwaterAcousticsStateComponent
1) Define the interface class that will be used to represent the next and curent frames. The UNDEFINED_ macros are convenience macros that will define methods that throw exceptions (until they are implemented)
Definition: underwaterAcousticsStateComponent.h:106

DtLocalObject::myControllersTicked
bool myControllersTicked
Definition: localObject.h:911

DtLocalObject::OverlayParent
Definition: localObject.h:100

DtLocalObject::myCommunicationInterface
DtVrfObjectCommunicationInterface * myCommunicationInterface
Definition: localObject.h:872

DtRwProperties
A list of properties. A DtPropertyInterface object that is a specialized version of DtRwVariableBindi...
Definition: rwProperties.h:126

DtLocalObject::myLocalObjectCreateInformation
DtVrfLocalObjectCreateInformation * myLocalObjectCreateInformation
Information used to originally create this object.
Definition: localObject.h:893

DtVrfObjectHandoffData::Prepare
If the flag is Prepare, and you do not wish this object to be handed off, set the flag to Abort...
Definition: localObject.h:67

DtLocalObject::signal_preUpgradeFromImport
boost::signals2::signal< void()> signal_preUpgradeFromImport
Signal sent when upgrading from import. This will be called before any internal routines are called...
Definition: localObject.h:486

makVrf::DtIffStateComponent
1) Define the interface class that will be used to represent the next and curent frames. The UNDEFINED_ macros are convenience macros that will define methods that throw exceptions (until they are implemented)
Definition: iffStateComponent.h:83

DtString

DtLocalVertexList
class DtLocalVertexList:
Definition: localVertexList.h:20

DtLocalObject::mySkipNextComponentTick
bool mySkipNextComponentTick
Definition: localObject.h:912

makVrf::DtTaskVisualizationStateComponent
1) Define the interface class that will be used to represent the next and current frames...
Definition: taskVisualizationStateComponent.h:260

stateComponent.h
Contains the DtStateComponent class declaration.

vrfobjcoreDefines.h

VRF4API_METHOD
#define VRF4API_METHOD
Include this header file to allow for the definition/usage of the ability to mark something as deprec...
Definition: vrf4XAPI.h:22

DtLocalObject::vrfState
VRF4API_METHOD DtVrfObjectStateRepository * vrfState()
These are backwards compatible methods that can be used if you define ALLOW_VRF4API in your header fi...
Definition: localObject.h:941

DtLocalObject::myAppearanceLocalObjectFacade
DtAppearanceLocalObjectFacade * myAppearanceLocalObjectFacade
Definition: localObject.h:900

DtLocalObject::myScriptInterfaceExtensions
ScriptInterfaceExtensions myScriptInterfaceExtensions
Definition: localObject.h:902

DtLocalObject::mySubComponentTypes
DtVrfObjectSubComponentTypes * mySubComponentTypes
Definition: localObject.h:870

DtLocalObject::getNextFrameStateComponentList
std::vector< T_Component * > getNextFrameStateComponentList()
General call to get any component that does not have a method.
Definition: localObject.h:127

makVrf::DtFrameStateInterface
This is a simple base class that will be used to return a pointer to current or next frame state...
Definition: stateComponent.h:291

DtVrfObjectHandoffData
Definition: localObject.h:61

DtLocalObject::theDoNotArchiveAttributes
static std::set< DtString > theDoNotArchiveAttributes
Definition: localObject.h:898

stateData.h

DtSimObject::isLocal
virtual bool isLocal() const
Returns true if this object is a locally simulated object.

DtLocalObject::isVrfSimulated
VRF4API_METHOD bool isVrfSimulated() const
These are backwards compatible methods that can be used if you define ALLOW_VRF4API in your header fi...
Definition: localObject.h:948

DtLocalObject::myVrfObjectPlanManager
DtVrfObjectPlanManager * myVrfObjectPlanManager
Definition: localObject.h:878

DtLocalObject::signal_prepareForHandoff
boost::signals2::signal< void(DtLocalObject *, DtVrfObjectHandoffData &)> signal_prepareForHandoff
Signal sent in preparing for handoff. Set the handoffFlag to Abort if this item should not be handed ...
Definition: localObject.h:632

simObject.h

DtLocalObjectDecorator
Definition: decoratorBase.h:44

DtLocalObject
A locally simulated VRF object. Holds all internal and external data for the object, and provides access to both the current frame and next frame state data for the object. All current frame data is read-only, and next-frame data can be written to. No thread safety guarantees are made on this object during the simulation frame and it should only be accessed by the thread that is simulating the object.
Definition: localObject.h:86

DtVrfCallbackQueue::CallbackInterface::Ptr
boost::shared_ptr< CallbackInterface > Ptr
Definition: vrfCallbackQueue.h:64