vrfObjectStateRepository.h

Go to the documentation of this file.

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


#pragma once

#include "vrfobjcore/simObjectStateRepository.h"
#include "vrfobjcore/groundInteractionPt.h"
#include "vrfobjparam/simSector.h"
#include "vrfutil/simResourceManager.h"
#include <vrfExtProtocol/objectType.h>
#include "vrfutil/echelonId.h"
#include <readerWriter/rwInt.h>
#include "vrfutil/rwJoystickControls.h"
#include "vrfobjcore/taskStatusList.h"
#include "vrfutil/rwTemplatedList.h"
#include <readerWriter/rwStringAttributeList.h>
#include "vrfobjcore/managedObjectList.h"
#include "vrfobjcore/attachedTerrain.h"
#include "vrfobjcore/vrfObject.h"
#include "vrfutil/sensorContactInfoList.h"
#include <readerWriter/rwProperties.h>
#include "vrfExtProtocol/rangeItem.h"
#include "vrfobjcore/suspendedTaskInfo.h"
#include "tbb/concurrent_hash_map.h"
#include "tbb/mutex.h"
#include <vrfutil/rwUUID.h>

#include <vlpi/appearance.h>
#include <vlpi/artPartSpec.h>
#include <vlutil/vlString.h>
#include <vlpi/thresholder.h>

#include <vlutil/vlConfig.h>
#include <map>
#include <list>

#include "boost/logic/tribool.hpp"

class DtVrfObjectGeometry;
class DtVrfObject;
class DtVrfObjectParameters;
class DtVrfSubordinateManager;
class DtSimManager;
class DtVrfProcessStateRepositoryManager;
class DtVrfWeaponPSR;
class DtRwAppearance;
class DtVrfObject;
class DtSimManager;
class DtTaskMessage;
class DtVrfObjectStateRepository;
class DtVrfStateRepositoryUserExtension;
class DtSignatureModifierEvaluator;
class DtAttachmentManager;
class DtArticulatedPartStateRepository;
class DtLegacyProcessStateRepositoryManager;
class DtObjectResourceManager;
class DtSubtaskStatusEntry;
class DtVrfObjectMessage;

const int DtEntityVisibilityTest = 1;
const int DtPolygonVisibilityTest = 2;
const int DtFeatureVisibilityTest = 3;

typedef bool (*DtVisibilityTest)(double rangeSquared, const DtEntityIdentifier& eyeKey,
      const DtVector& localEyePoint, const DtVector& localEndPoint, const DtVrfObjectStateRepository* sr);

typedef void (*DtPostInitializeFromParametersCallbackFcn)(DtVrfObjectStateRepository& stateRepository,
                                                          void* usr);

#include "vrfobjcore/vrfobjcoreDefines.h"
class DT_DLL_vrfobjcore DtVrfObjectStateRepository : public DtSimObjectStateRepository
{
protected:
   DtVrfObjectStateRepository();

public:
   typedef std::map<DtString, DtString> ExtendedData;
   typedef std::map<int, DtString> ExtendedLabels;

   typedef std::map<DtString, std::map<DtString, DtRwJoystickControl> > JoystickControls;

   DtVrfObjectStateRepository(DtVrfObject* vrfObject, 
      const DtObjectType& objectType, DtVrfObjectParameters* parameters,
      const DtString& rwName = DtString::nullString(),  
      DtReaderWriterRegistry* parentRegistry = 0);

   DtVrfObjectStateRepository(const DtVrfObjectStateRepository& orig,
      const DtString& rwName = DtString::nullString(), 
      DtReaderWriterRegistry*  parentRegistry = 0);

   const DtVrfObjectStateRepository& operator=(
      const DtVrfObjectStateRepository& orig);

   virtual ~DtVrfObjectStateRepository();

   virtual DtSimObjectStateRepository* clone(
      const DtString& rwName = DtString::nullString(), 
      DtReaderWriterRegistry*  parentRegistry = 0) const;

   virtual DtString type() const;

   virtual const int objectStateRepositorySubType() const;

   virtual const int vrfObjectStateRepositorySubType() const;

   virtual bool init();

   virtual bool createParameters();
   virtual void initializeFromParameters();
   virtual const DtVrfObjectParameters* vrfParameters() const;

   virtual void setConcealed(bool);

   virtual void setJoystickMovementControlled(bool);
   virtual bool joystickMovementControlled() const;

   virtual DtVrfStateRepositoryUserExtension* userExtension() const;

   virtual void restoreEntity();


   virtual void addRestoredCallback(
      DtVrfObjectCallbackList::DtCallbackFunctionType fcn, void* usr);
   virtual void removeRestoredCallback(
      DtVrfObjectCallbackList::DtCallbackFunctionType fcn, void* usr);
   virtual void invokeRestoredCallbacks();

   virtual void updateCachedStateProperties();

   virtual void setExtendedData(const DtString& key, const DtString& value);
   virtual void clearExtendedData();
   virtual void removeExtendedData(const DtString& key);
   virtual DtString extendedData(const DtString& key) const;
   const ExtendedData& extendedDataMap() const
   {
      return myExtendedData;
   }
   virtual void setExtendedDataMap(const ExtendedData&);
   virtual void setExtendedDataMap(const std::map<std::string, std::string>&);

   virtual void setupExtendedDataFromParameterData();

   virtual void setExtendedLabel(int, const DtString& value);
   virtual void clearExtendedLabels();
   virtual DtString extendedLabel(int index) const;
   virtual ExtendedLabels extendedLabels() const;
   virtual void setExtendedLabels(const ExtendedLabels&);

   virtual void addJoystickControls(const DtRwJoystickControls&);
   virtual const JoystickControls& joystickControls() const;

   virtual void setActivity(const DtString&);
   virtual DtString activity() const;


   virtual const DtObjectResourceManager* objectResourceManager() const;
   virtual DtObjectResourceManager* objectResourceManager();


   virtual const DtSimResourceManager& oldResourceManager() const;
   virtual DtSimResourceManager& oldResourceManager();

   virtual DtSimResource* oldLookupResource(const DtString & resourceName);
   virtual const DtSimResource* oldLookupResource(const DtString & resourceName) const;

   virtual void oldAddResource(DtSimResource* resource);

   virtual void oldRemoveResource(DtSimResource* resource);

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

   virtual bool wouldBeRecursiveAttach(DtSimObjectStateRepository* parent) const;

   virtual void restoreResourcesFromParameters();


   virtual void setSOR(DtReal center, DtReal size);

   virtual DtReal SORSize() const;
   virtual DtReal SORCenter() const;

   virtual const DtSimSector& SOR() const;

   virtual bool isContactHostile(DtRwSensorContactInfo*) const;

   virtual bool isContactHostile(DtVrfObject*) const;

   virtual bool isContactHostile(const DtVector& location, int perceivedForce) const;

   virtual bool inSOR(const DtVrfObject* entity) const;

   virtual bool canFireAt(const DtVector& location) const;

   virtual const DtString& engagementRules() const;
   virtual void setEngagementRules(const DtString& engagementRules);


   virtual void setRequestTaskNeeded(bool value);
   virtual bool requestTaskNeeded() const;


   virtual void setTasked(const DtSymbolString& componentName, bool tasked);
   virtual void setTasked(const DtSymbolString& componentName, int taskID, bool tasked);
   virtual bool tasked(const DtSymbolString& componentName) const;

   virtual bool isTasked() const;

   virtual void clearCurrentTaskMsg(const DtSymbolString& componentName);

   virtual void clearCurrentTaskMsg(const DtSymbolString& componentName, int taskId);


   virtual void setCurrentTaskMsg(const DtSymbolString& componentName, 
      const DtTaskMessage & taskMsg);

   virtual void setCurrentTaskMsg(const DtSymbolString& componentName, 
      const DtTaskMessage & taskMsg, int taskId);

   virtual const DtTaskStatusList* taskStatusList() const;
   virtual DtTaskStatusList* taskStatusList();
   virtual DtSuspendedTaskStatusList* suspendedTaskStatusList();
   
   virtual DtTaskMessage* currentTaskMsg(const DtSymbolString& componentName) const;

   virtual DtTaskMessage* currentTaskMsg(const DtSymbolString& componentName, int taskId) const;

   virtual std::list<DtTaskMessage*> allCurrentTaskMsg(const DtSymbolString& componentName) const;

   static bool shouldArchiveExtendedAttribute(const DtString&);
   static void doNotArchiveAttribute(const DtString&, bool);

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

   virtual bool placePoints(DtAttachedTerrain& attachedTerrain, 
      std::vector<DtGroundInteractionPt*> groundInteractionPts, 
      bool* terrainDataAvailable = 0);

   virtual void updateSupportPoints(const DtVector& newPosition, 
                                    const DtReal newHeading);


   virtual void setIndependentlyTasked(bool value);
   virtual bool independentlyTasked() const;


   virtual bool processCompleteAttachment(DtVrfObject*);
   static void objectAboutToBeRemovedCallback(DtVrfObject * vrfObject, void * usr);
   virtual void processObjectAboutToBeRemovedCallback(DtVrfObject * vrfObject);   

   static DtVrfObjectStateRepository* createRepository(const DtString & name, 
      const DtString & type, DtVrfObject* simObject,
      const DtObjectType & objectType, DtVrfObjectParameters* parameters, 
      DtReaderWriterRegistry* parentRegistry = 0);

   static void addSimObjectStateRepositoryCreatorFcn(const DtString & type, 
      DtSimObjectStateRepositoryCreatorFcn fcn);


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


   virtual const DtVrfObjectParameters* parameterEntry() const;
   virtual  void setParameterEntry(DtVrfObjectParameters* parameterEntry);

   virtual const DtVrfObjectParameters* parameters() const;

   virtual DtVrfObjectParameters* modifiableParameters();
   virtual void setupParameterInheritance();


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

   virtual bool createAttachments();

   void addPart(DtArticulatedPartStateRepository * part);
   void removePart(DtArticulatedPartStateRepository * part);
   DtArticulatedPartStateRepository * part(DtArtPartType partType);

   DtArticulatedPartStateRepository * findDescendantByType(
      DtArtPartType childType);


   virtual bool createAppearance();
   virtual const DtAppearance* appearance() const;
   virtual DtAppearance* appearance();


   virtual void setCapabilities(int cap);
   virtual int capabilities() const;
   

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

   virtual void setInvisible(bool);
   virtual bool invisible() const;


   virtual void setOccupantsHidden(bool v);
   virtual bool occupantsHidden() const;

   virtual void setInvulnerable(bool);
   virtual bool invulnerable() const;

   virtual void setInvisibleSetByUser(bool);
   virtual bool invisibleSetByUser() const;


   DtReal healthPct() const;
   void setHealthPct(DtReal pct);


   bool firePowerKilled() const;
   void setFirePowerKilled(const bool firePowerKilled);

   bool mobilityKilled() const;
   void setMobilityKilled(const bool mobilityKilled);

   bool flaming() const;
   void setFlaming(const bool flaming);

   bool smoking() const;
   void setSmoking(const bool smoking);

   bool sensorsKilled() const;
   void setSensorsKilled(bool sensorsKilled);

   bool isEntity() const;

   bool isLocal() const;

   bool isAggregate() const;


   virtual DtVrfSubordinateManager* subordinates();
   virtual const DtVrfSubordinateManager* subordinates() const;

   void addSubordinate(DtVrfObject* subordinateEntity);

   void removeSubordinate(DtVrfObject* subordinateEntity);

   virtual DtSharedVrfObjectReference leadEntity() const;

   virtual DtSharedVrfObjectReference firstSubordinate() const;

   virtual DtSharedVrfObjectReference lastSubordinate() const;

   virtual DtSharedVrfObjectReference firstHealthySubordinate() const;


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


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

   virtual void tick();

   virtual void timedTick();
   
   virtual void setMinTickPeriod(double minTickPeriod);

   virtual double minTickPeriod() const;

   virtual void setMinTickPeriodVariance(double minTickPeriodVariance);

   virtual double minTickPeriodVariance() const;

   virtual void setNextTickTime(double nextTickTime);

   virtual double nextTickTime() const;

   virtual double calculateNextTickTime() const;

   virtual bool createSubordinates();
   virtual DtVrfSubordinateManager* vrfSubordinates();
   virtual const DtVrfSubordinateManager* vrfSubordinates() const;

   virtual bool createProcessStateRepositoryManager();

   virtual const DtVrfProcessStateRepositoryManager* 
       systemProcessStateRepositoryManager() const;
   virtual DtVrfProcessStateRepositoryManager* systemProcessStateRepositoryManager();

   virtual const DtTaitBryan& localOrientationWrtDatabase() const;
   virtual void setLocalOrientationWrtDatabase(
      const DtTaitBryan& localOrientation);

   virtual DtVrfWeaponPSR* firstWeaponPSR() const;

   virtual void processObjectGeometry(const DtList& vertices);
   virtual void processObjectGeometry(const DtLocalVertexList& vertices);

   virtual void processObjectGeometry();

   virtual const DtVrfObjectParameters* vrfBaseParameters() const;

   virtual DtGroundInteractionPt* groundCenter();
   virtual const DtGroundInteractionPt* groundCenter() const;

   virtual const DtVector& getPartAttachPoint(const int partType) 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 clampToGroundFlag = true, bool* dataAvailable = 0,
      bool requireAllData = false);

   virtual void reclampToGround();

   virtual void updatePositionFromModelVertices();

   virtual DtReal mass() const;
   virtual void setMass(const DtReal mass);

   virtual const DtArticulatedPartCollection* artPartList() const;

   virtual void createParts();

   virtual DtTime lastTimeFiredUpon() const;
   virtual void setLastTimeFiredUpon(const DtTime time);

   virtual bool underFire() const;
   virtual void setUnderFire(bool underFire);

   enum suppressionLevels {
      DtNoSuppression = 0,
      DtSuppressed1 = 1,
      DtSuppressed2 = 2,
      DtSuppressed3 = 3
   };
   virtual suppressionLevels suppressionLevel() const;
   virtual void setSuppressionLevel(const suppressionLevels l);
   virtual bool isSuppressed() const;

   virtual DtDeadReckonTypes deadReckoningAlgorithm() const;
   virtual void setDeadReckoningAlgorithm(
      DtDeadReckonTypes deadReckoningAlgorithm);


   virtual const DtThresholder& deadReckoningThresholder() const;
   virtual void setDeadReckoningThresholder(
      const DtThresholder& thresholder);


   virtual const DtEntityIdentifier & occupyingObjectId() const;
   virtual void setOccupyingObjectId(const DtEntityIdentifier & objId);


   virtual void setEchelonId(const DtEchelonId& echelonId);
   virtual DtEchelonId& echelonId();
   virtual const DtEchelonId& echelonId() const;


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

   virtual void putData(std::string& fp, int indentLevel = 0);

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

   virtual int nextTaskId();

   virtual int nextSuspendId();



   virtual int spawningTaskId(int subtaskId) const;

   virtual void addPendingSubtaskId(const DtSymbolString& componentName, int subtaskId);
   virtual void addPendingSubtaskId(const DtSymbolString& componentName, int taskId, int subtaskId);
   virtual bool findPendingSubtaskId(const DtSymbolString& componentName, int subtaskId);
   virtual bool isSubtasked(const DtSymbolString& componentName) const;
   virtual bool findPendingSubtaskId(const DtSymbolString& componentName, int taskId, int subtaskId);
   virtual void removePendingSubtaskId(const DtSymbolString& componentName, int subtaskId);
   virtual void removePendingSubtaskId(const DtSymbolString& componentName, int taskId, int subtaskId);
   virtual void removeAllPendingSubtaskIds(const DtSymbolString& componentName);
   virtual void removeAllPendingSubtaskIds(const DtSymbolString& componentName, int taskId);
   virtual void removeInactiveSubtaskStatus(const DtSymbolString& componentName);
   virtual void removeInactiveSubtaskStatus(const DtSymbolString& componentName, int taskId);
   virtual void printPendingSubtaskIds(const DtSymbolString& componentName) const;
   virtual std::vector<int> currentPendingSubstaskIds(const DtSymbolString& componentName) const;
   virtual std::vector<int> currentPendingSubstaskIds(const DtSymbolString& componentName, int taskId) const;
   virtual DtSubtaskStatusEntry* pendingSubtaskStatus(const DtSymbolString& componentName, int subtaskId);
   virtual DtSubtaskStatusEntry* pendingSubtaskStatus(const DtSymbolString& componentName, int taskId, int subtaskId);

   virtual DtTaskMessage* pendingSubtask(int subtaskId, DtString& controller) const;

   virtual bool taskedBySuperiorUponTaskComplete() const;

   virtual void setParentWasDestroyedWhenEmbarked(bool);
   virtual bool parentWasDestroyedWhenEmbarked() const;

   virtual void detachFromParent();
   virtual void attachToParent(DtSimObjectStateRepository* parent);
   virtual void attachToParent(const DtUUID& parent);

   virtual void addAttachedTerrain(const DtUUID& parent);

   virtual void removeAttachedTerrain(const DtUUID& parent);

   Dt3dBoundingVolume* boundingVolume() const;

   DtVector localBoundingVolumeCenterPosition() const;


   DtReal currentSpeed() const;

   DtReal forwardSpeed() const;

   virtual double totalMass() const;


   DtReal currentHeading() const;
   void setCurrentHeading(const DtReal heading);


   virtual const DtRwNLengthUUIDVector& engagementZones() const;
   virtual void setEngagementZones(const DtRwNLengthUUIDVector&);


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

   virtual void restoreStateProperties();

   virtual void initStatePropertiesNotToBeRestored();


   virtual DtRwProperties& stateProperties();
   virtual const DtRwProperties& stateProperties() const;


   virtual DtRwProperties& parameterProperties();
   virtual const DtRwProperties& parameterProperties() const;

protected:

   virtual void initializeNextTaskId();

   virtual void setOrientationRelativeToParent();

   virtual DtAttachedTerrain* createAttachedTerrain();

   virtual DtArticulatedPartStateRepository* createArtPartStateRepository(
      DtVrfObject* vrfObject, const DtObjectType& objectType, 
      const DtString& rwName = DtString::nullString());

public:

   //{@
   virtual void addRangeItem(const DtRangeItem&);
   virtual void removeRangeItem(int index);
   virtual void setRangeItems(const DtRangeItems&);
   const DtRangeItems& rangeItems() const;
   DtRangeItems& rangeItems();
   virtual void clearRangeItems();

   DtAttachedTerrain* terrainAttachedTo() const;

   virtual boost::tribool onTerrainSurface() const;

   virtual double sensorSignature(const DtSymbolString& sensorDomain) const;

   virtual std::list<DtSymbolString> sensorSignatureDomains() const;


   virtual DtSensorContactInfoList& objectContactList();
   virtual const DtSensorContactInfoList& objectContactList() const;

   virtual DtString stringFromExtendedData(const DtString&) const;

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

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

protected:
   virtual double baseSensorSignature(const DtSymbolString& sensorDomain) const;

   virtual double modifySensorSignature(const DtSymbolString& sensorDomain, 
      double baseSignature) const;

   virtual bool initSignatureEvaluators();

   void clearSignatureEvaluators();

   virtual bool createObjectResourceManager();

   virtual void invokePostInitFromParamsCallbacks();

public:

   static void taskCompleteCallback(const DtVrfObjectMessage* msg, void* usr);
   virtual void processTaskComplete(const DtVrfObjectMessage* msg);

   static DtVrfObjectStateRepository * creator(const DtString& name, 
      DtVrfObject* simObject, const DtObjectType& objectType, 
      DtVrfObjectParameters * parameters, 
      DtReaderWriterRegistry * parentRegistry);

   static DtVrfObjectStateRepository* isVrfObjectStateRepository(
      DtSimObjectStateRepository* repository);

   static const DtVrfObjectStateRepository* isVrfObjectStateRepository(
      const DtSimObjectStateRepository* repository);

   virtual DtVrfObjectStateRepository* toVrfObjectStateRepository();
   virtual const DtVrfObjectStateRepository* toVrfObjectStateRepository() const;

protected:

   static bool visibilityFilter(const DtVrfObject * object, void * usr);

protected:

   DtVrfStateRepositoryUserExtension* myStateRepositoryUserExtension;

   DtRwAppearance*          myAppearance;
   DtRwInt                  myCapabilities;

   DtRwBoolean              mySensorsKilled;

   DtRwForceType            myForceType;

   DtRwNLengthUUIDVector    myEngagementZones;

   DtVrfSubordinateManager*    mySubordinates;

   DtRwUUID myParent;

   DtVrfProcessStateRepositoryManager* mySystemProcessSRManager;
   DtLegacyProcessStateRepositoryManager* myLegacyPSRManager;

   DtSimManager*              mySimManager;

   DtGroundInteractionPt     myGroundCenter;

   bool                      myUnderFire;
   DtTime                    myLastTimeFiredUpon;
   
   DtRwInt mySuppressionLevel;

   DtReal                    myMass;
   DtDeadReckonTypes         myDeadReckoningAlgorithm;
   DtThresholder             myDeadReckoningThresholder;

   DtEntityIdentifier        myOccupyingObjectId;

   DtArticulatedPartCollection            myArtPartList;

   DtManagedObjectListConstPtr  myVisibilityFilterList;

   DtRwVector                myLocalPosition;
   DtRwTaitBryan             myLocalOrientation; 
   DtRwBoolean               myIsDestroyedFlag;

   DtEchelonId               myEchelonId;
   DtRwBoolean               myIsSubordinateOfForceLevel;

   DtRwInt                   myDesignator;

   DtRwBoolean               myIndependentlyTasked;

   static DtSimObjectStateRepositoryFactory* theFactory;

   DtSimResourceManager      myResourceManager;

   DtObjectResourceManager* myObjectResourceManager;

   DtRwString                myEngagementRules;

   DtSimSector               mySectorOfResponsibility;

   DtRwBoolean myRequestTaskNeeded;

   DtTaskStatusList myTaskStatusList;

   DtSuspendedTaskStatusList mySuspendedTaskStatusList;

   DtRwInt myNextTaskId;
   DtRwInt myNextSuspendId;

   DtRwBoolean myParentWasDestroyedWhenEmbarked;

   DtRwBoolean myNavigationEnabled;

protected:
   //***** Important API change note
   //*****

   const DtVrfObjectParameters*   myParameterEntry;

   DtVrfObjectParameters*   myParameters;

   double myMinTickPeriod;
   double myMinTickPeriodVariance;
   double myNextTickTime;
   double myLastTickSimTime;

   DtAttachedTerrain* myTerrainAttachedTo;

   typedef std::list<DtSignatureModifierEvaluator*> DtSignatureModifierEvalList;
   typedef std::map<DtSymbolString, DtSignatureModifierEvalList*> DtSignatureModifierEvalMap;
   DtSignatureModifierEvalMap mySignatureModifierEvalMap;

   typedef tbb::concurrent_hash_map<unsigned int, double> DtSensorSignatureCacheMap;
   mutable DtSensorSignatureCacheMap myMutableSensorSignatureCacheMap;

   DtSensorContactInfoList myObjectContactList;

   typedef std::pair<DtPostInitializeFromParametersCallbackFcn, void*> DtPostInitializeFromParametersInfo;
   typedef std::list<DtPostInitializeFromParametersInfo> DtPostInitializeFromParametersCallbackList;

   DtPostInitializeFromParametersCallbackList myPostInitFromParamsCallbackList;

   DtRangeItems myRangeItems;
   std::vector<DtRangeItem> myFixedRangeItems;

   DtRwProperties myStateProperties;
   DtRwProperties myParameterProperties;
   ExtendedData myExtendedData;
   DtRwStringAttributeList myRwExtendedData;

   bool myUsingTempStateProperties;
   DtRwProperties myTempStateProperties;

   std::vector<DtString> myStatePropertiesNotToBeRestored;

   mutable tbb::mutex myEvaluateSensorSignatureMutex;

   JoystickControls myJoystickControls;

   bool myJoystickMovementControlled;

   std::set<DtArticulatedPartStateRepository*> myArtParts;

   static std::set<DtString> theDoNotArchiveAttributes;

   DtVrfObjectCallbackList myRestoredCallbacks;
};