simObject.h

Go to the documentation of this file.

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

#pragma once

#include "vrfobjcore/vrfobjcoreDefines.h"
#include "vrfobjcore/simObjectReference.h"
#include "vrfobjcore/vrfLocalObjectCreateInformation.h"
#include "vrfobjcore/aggregateSimObjectFacade.h"
#include "vrfobjcore/platformSimObjectFacade.h"
#include "vrfStateData/stateData.h"
#include "vrfStateData/vrfObjectGeometry.h"
#include <vrfStateData/vrfGeometryStateComponent.h>
#include <vrfobjcore/vrfSimulatedSimObjectFacade.h>
#include <vrfStateData/vrfStateComponent.h>
#include <vrfStateData/locationStateComponent.h>
#include <vrfStateData/entityStateComponent.h>
#include "vrfExtProtocol/objectType.h"
#include "vrfStateData/rwVrfKinematicState.h"
#include "features/featureGeometry.h"
#include "vlpi/entityIdentifier.h"
#include <boost/signals2.hpp>
#include <matrix/vlVector.h>
#include <geometry/extent.h>
#include <vrfutil/rwUUID.h>
#include <vlpi/appearance.h>
#include <vlpi/disEnums.h>
#include <matrix/vlDcm.h>
#include <matrix/vlTaitBryan.h>
#include <matrix/3dBoundingVolume.h>
#include <map>
#include <list>
#include <tbb/spin_rw_mutex.h>
#include "features/featureGeometry.h"
#include <vrfutil/vrf4XAPI.h>

class DtSimObjectDecorator;

namespace makVrf
{
   class DtIffStateComponent;
   class DtLaserDesignatorStateComponent;
   class DtExternalCurrentFrameState;
   class DtStateData;
}

class DtRwSimObjectReferenceList;
class DtSubordinateManager;
class DtRangeItems;
class DtLocalVertexList;
class DtVertexList;
class DtSimulationServices;
class DtSymbolString;
class DtRwProperties;
class DtRwReal;
class DtVrfObjectParameters;
class DtOutputStream;
class DtObjectConsole;
class Coordinate_System;
class DtSimObject;
class DtChord;
class DtAttachedTerrain;
class DtPhysicalWorld;
class DtSimObjectManager;
class DtVrfObjectStateRepository;
class DtSimObjectReferenceList;

class DT_DLL_vrfobjcore DtSimObject
{
private:
   DtSimObject();
   DtSimObject(const DtSimObject&);

public:
   explicit DtSimObject(const DtSimulationServices* simManager, const DtUUID& uuid);
   explicit DtSimObject(const DtSimulationServices* simManager, const DtEntityIdentifier& id);
   explicit DtSimObject(const DtSimulationServices* simManager, const makVrf::DtExternalCurrentFrameState*);

   virtual ~DtSimObject();

   DtSimObject& operator=(const DtUUID&);
   DtSimObject& operator=(const DtSimObject& rhs) { return operator=(rhs.uuid()); };

   bool operator==(const DtUUID& rhs) const;
   bool operator==(const DtSimObject& rhs) const { return (*this == rhs.uuid()); };

   bool operator!=(const DtUUID& rhs) const { return !(*this == rhs); };
   bool operator!=(const DtSimObject& rhs) const { return !(*this == rhs); };

   const DtUUID& uuid() const;
   const DtString& objectName() const;
   DtEntityType entityType() const;
   DtObjectType objectType() const;

   bool isBackgroundEntity() const;

   makVrf::DtVrfObjectGeometry objectGeometry() const;
   Dt3dBoundingVolume boundingVolume() const;
   DtVector localBoundingVolumeCenterPosition() const;
   DtExtent extent() const;

   DtExtent roughExtent() const;
   void expandExtent(DtExtent& extent) const;

   const makVrf::DtIffStateComponent* iffStateComponent() const;
   std::vector<const makVrf::DtLaserDesignatorStateComponent*> laserDesignatorStateComponents() const;

   template <typename T_Component>
   const T_Component* getStateComponent() const
   {
      return myExternalCurrentFrameState->getStateComponent<T_Component>();
   }

   template <typename T_Component>
   std::vector<const T_Component*> getStateComponentList() const
   {
      return myExternalCurrentFrameState->getStateComponentList<T_Component>();
   }

   template <typename T_Component>
   bool hasStateComponent() const
   {
      return myExternalCurrentFrameState->hasStateComponent<T_Component>();
   }

   makVrf::DtRwVrfKinematicState kinematicState() const;

   const DtVector& worldPosition() const;
   const DtVector&localPosition() const;
   const DtVector&parentPosition() const;
   double distSquaredTo(const DtVector&) const;

   bool hasLocationChanged() const;

   bool objectVerticesChanged() const;

   bool worldVerticesChanged() const;

   bool haveVerticesChanged() const;

   virtual void frameAdvanced();
   virtual void firstFrameAdvance();

   const DtTaitBryan& topographicOrientation() const;
   const DtTaitBryan&  worldOrientation() const;
   const DtTaitBryan&  localOrientation() const;
   const DtTaitBryan&  parentOrientation() const;
   const DtTaitBryan&  localOrientationWrtDatabase() const;
   const DtDcm& localOrientationMatrix() const;
   const DtDcm& parentOrientationMatrix() const;
   const DtDcm& worldOrientationMatrix() const;
   double heading() const;
   double pitch() const;
   double roll() const;
  
   virtual bool isLocal() const;

   DtForceType forceType() const;

   const DtEntityIdentifier& entityId() const;
   const DtEntityIdentifier& objectIdentifier() const
   {
      return entityId();
   }

   bool isDestroyed() const;
   int damageState() const;

   const DtString& globalId() const;

   bool isUnit() const;

   const DtPlatformSimObjectFacade& platformSimObjectFacade() const;

   const DtVrfSimulatedSimObjectFacade& vrfSimulatedSimObjectFacade() const;

   bool isEntityOrUnit() const;
   bool isSimulatedObject() const { return isEntityOrUnit(); };

   bool isEntity() const;

   bool isEmbarked() const;

   DtUUID embarkedOn() const;
   DtSimObjectReference simObjectEmbarkedOn() const;
   bool isEmbarkedOn(const DtUUID&) const;

   bool isValid() const;
   
   int sessionId() const;
   bool isVrfSimulatedObject() const;

   bool isOnTopOf(const DtSimObject* o) const;

   bool isOnTopOf(const DtSimObject* o, double d) const;

   bool isOnTopOf(const DtSimObject* o, double d, const DtVector& position) const;

   bool isDeleted() const;

   virtual DtVrfLocalObjectCreateInformation vrfLocalObjectCreateInformation() const;

   virtual void makeInvalid();

   const DtSimulationServices* simulationServices() const
   {
      return mySimulationServices;
   }

   const DtVrfObjectParameters* parameters() const
   {
      return myParameters;
   }

   DtVrfObjectParameters* duplicateParameters();

   double totalMass() const;

   const Coordinate_System* coordinateSystem() const;

   const DtLocalVertexList& localVertices() const;
   const DtVertexList& worldVertices() const;
   const DtLocalVertexList& relativeVertices() const;

   DtVector locationRelativeTo(const DtVector&, const DtSimObject* relativeTo) const;

   DtVector velocityRelativeTo(const DtVector&, const DtSimObject* relativeTo) const;

   DtVector accelerationRelativeTo(const DtVector&, const DtSimObject* relativeTo) const;

   DtTaitBryan orientationRelativeTo(const DtTaitBryan&, const DtSimObject* relativeTo) const;

   const DtRwProperties& parameterProperties() const;

   double distanceToLocalVector(const DtVector&) const;

   DtSimObjectReference simObjectReference() const;

   unsigned long long legionGlobalId() const;

   DtString awaiting() const
   {
      return myAwaiting;
   }

   bool advancedFrame() const
   {
      return myAdvancedFrame;
   }

   DtSimObjectReference superior() const;
   DtUUID superiorUUID() const;

   const DtSimObjectReferenceList& attachments() const;

   bool isTopLevel() const;

   MAKVRinTerra::DtFeatureGeometry featureGeometry() const;

   const DtAttachedTerrain* terrainAttachedTo() const;

public:
   boost::signals2::signal<void ()> signal_objectVerticesChanged;

   boost::signals2::signal<void (const DtSimObject*)> signal_extendedDataUpdated;

   mutable boost::signals2::signal<void (const DtSimObject*)> signal_simObjectDeleted;

   mutable boost::signals2::signal<void (const DtSimObject*, const DtString&)> signal_discoveredReference;

   mutable boost::signals2::signal<void (const DtUUID& oldUUID, const DtUUID& newUUID)> signal_uuidChanged;

   mutable boost::signals2::signal<void (const DtSimObject*, const DtString& oldName, const DtString& newName)> signal_objectRenamed;

   mutable boost::signals2::signal<void (const DtSimObject*, const DtUUID& oldSuperior, const DtUUID& newSuperior)> signal_superiorChanged;

   mutable boost::signals2::signal<void ()> signal_advancedFrame;

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

public:
   virtual void clearDecorators();

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

   inline const makVrf::DtSimulatedObjectStateComponent* currentFrameSimulatedObjectStateComponent() const
   {
      if (myCurrentFrameSimulatedObjectStateComponent)
      {
         return myCurrentFrameSimulatedObjectStateComponent;
      }
      else if (!myCachedComponents && hasStateComponent<makVrf::DtSimulatedObjectStateComponent>())
      {
         return getStateComponent<makVrf::DtSimulatedObjectStateComponent>();
      }
      else
      {
         return nullptr;
      }
   }

   inline const makVrf::DtLocationStateComponent* currentFrameLocationStateComponent() const
   {
      if (myCurrentFrameLocationStateComponent)
      {
         return myCurrentFrameLocationStateComponent;
      }
      else if (!myCachedComponents && hasStateComponent<makVrf::DtLocationStateComponent>())
      {
         return getStateComponent<makVrf::DtLocationStateComponent>();
      }
      else
      {
         return nullptr;
      }
   }

   inline const makVrf::DtVrfGeometryStateComponent* currentFrameVrfGeometryStateComponent() const
   {
      if (myCurrentFrameVrfGeometryStateComponent)
      {
         return myCurrentFrameVrfGeometryStateComponent;
      }
      else if (!myCachedComponents && hasStateComponent<makVrf::DtVrfGeometryStateComponent>())
      {
         return getStateComponent<makVrf::DtVrfGeometryStateComponent>();
      }
      else
      {
         return nullptr;
      }
   }

   inline const makVrf::DtEntityStateComponent* currentFrameEntityStateComponent() const
   {
      return myCurrentFrameEntityStateComponent;
   }

   inline const makVrf::DtVrfStateComponent* currentFrameVrfStateComponent() const
   {
      if (myCurrentFrameVrfStateComponent)
      {
         return myCurrentFrameVrfStateComponent;
      }
      else if (!myCachedComponents && hasStateComponent<makVrf::DtVrfStateComponent>())
      {
         return getStateComponent<makVrf::DtVrfStateComponent>();
      }
      else
      {
         return nullptr;
      }
   }

protected:
   void cacheComponents();
   void clearCachedComponents();

   void stateDataAdded(makVrf::DtStateData*);
   virtual void setupVrfObjectParameters();
   virtual void setUUID(const DtUUID&);
   bool checkAndConnectForVrfStateComponent();

   void uuidChanged(const DtUUID&, const DtUUID&);
   void objectNameChanged(const DtString& oldText, const DtString& newText);

   void attachmentsChanged();
   virtual void completeSetup();
   void extendedDataUpdated();
   void superiorChanged();

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

   virtual void usingParameterSource(const DtString&);
   virtual void externalFrameStateToBeDestroyed();

private:
   friend class DtSimObjectManager;
   void resetUUID(const DtUUID&);

protected:
   const DtSimulationServices* mySimulationServices;
   const makVrf::DtExternalCurrentFrameState* myExternalCurrentFrameState;

   typedef std::map<std::string, DtSimObjectDecorator*> SimObjectDecorators;
   mutable SimObjectDecorators mySimObjectDecorators;
   mutable tbb::spin_rw_mutex mySimObjectDecoratorMutex;

   boost::signals2::scoped_connection myDeletedConnection;
   boost::signals2::scoped_connection myAddedConnection;
   boost::signals2::scoped_connection myUUIDChangedConnection;
   boost::signals2::scoped_connection myObjectNameChangedConnection;
   boost::signals2::scoped_connection myExtendedDataUpdatedConnection;
   boost::signals2::scoped_connection myFirstFrameAdvancedConnection;
   boost::signals2::scoped_connection mySuperiorChangedConnection;
   boost::signals2::scoped_connection myAdvancedFrameConnection;

   struct ExtentInformation
   {
      ExtentInformation() : lastSimTime(-1.), physicalFootprint(nullptr) {};
      double lastSimTime;
      const DtRwReal* physicalFootprint;
      DtExtent extent;
      DtVector lastPosition;
      tbb::spin_rw_mutex mutex;
   };

   mutable ExtentInformation myExtentInformation;

   DtString myAwaiting;

   DtUUID myUUID;
   unsigned long long myLegionGlobalId;

   const DtVrfObjectParameters* myParameters;
   
   DtVrfObjectParameters* myDuplicateParameters;

   bool myIsDeleted;

   mutable DtString myObjectName;
   mutable DtObjectType myEntityType;

   DtSimObjectReferenceList* myAttachments;
   boost::signals2::scoped_connection myAttachmentsChangedConnection;

   DtSimObjectReference mySuperior;
   bool myAdvancedFrame;

   mutable DtSimObjectReference mySimObjectReference;
   mutable tbb::spin_rw_mutex mySimObjectReferenceMutex;

   DtAttachedTerrain* myTerrainAttachedTo;
   boost::signals2::scoped_connection myHostChangedConnection;

   mutable tbb::spin_rw_mutex myExternalCurrentFrameStateMutex;

   DtUUID myEmbarkedOn;

   const makVrf::DtSimulatedObjectStateComponent* myCurrentFrameSimulatedObjectStateComponent;
   const makVrf::DtVrfStateComponent* myCurrentFrameVrfStateComponent;
   const makVrf::DtEntityStateComponent* myCurrentFrameEntityStateComponent;
   const makVrf::DtLocationStateComponent* myCurrentFrameLocationStateComponent;
   const makVrf::DtVrfGeometryStateComponent* myCurrentFrameVrfGeometryStateComponent;

   bool myCachedComponents;
   DtAggregateSimObjectFacade* myAggregateSimObjectFacade;
   DtPlatformSimObjectFacade* myPlatformSimObjectFacade;
   DtVrfSimulatedSimObjectFacade* myVrfSimulatedSimObjectFacade;

public:
   VRF4API_METHOD const DtSimObject* vrfState();
   VRF4API_METHOD const DtSimObject* vrfState() const;
   VRF4API_METHOD const DtSimObject* simState();
   VRF4API_METHOD const DtSimObject* simState() const;
   VRF4API_METHOD bool operator==(const DtSimObject* rhs) const { if (!rhs) return false; else return (uuid() == rhs->uuid()); };
   VRF4API_METHOD const DtSimulationServices* simManager() const;
   VRF4API_METHOD DtSimulationServices* simManager();
   VRF4API_METHOD makVrf::DtVrfObjectGeometry vrfObjectGeometry() const;
   VRF4API_METHOD const DtPhysicalWorld* physicalWorld() const;
   VRF4API_METHOD DtSimObjectReference sharedReference() const { return simObjectReference(); };
   VRF4API_METHOD const DtVrfObjectParameters* parameterEntry() const;
   VRF4API_METHOD const DtSimObjectManager* simObjectManager() const;
   VRF4API_METHOD DtSimObjectReference vrfObject() const;
   VRF4API_METHOD DtSimObjectReference parent() const;
   VRF4API_METHOD double currentHeading() const;
   VRF4API_METHOD double currentPitch() const;
   VRF4API_METHOD double currentRoll() const;
   VRF4API_METHOD const DtString& markingText() const;

   VRF4API_METHOD bool isSpatiallyFrozen() const;
   VRF4API_METHOD bool isFrozen() const;

   VRF4API_METHOD double speed() const;

   VRF4API_METHOD double forwardSpeed() const;
   VRF4API_METHOD DtVector worldVelocity() const;
   VRF4API_METHOD DtVector localVelocity() const;
   VRF4API_METHOD DtVector bodyVelocity() const;
   VRF4API_METHOD DtVector relativeVelocity() const;
   VRF4API_METHOD DtVector parentVelocity() const;
   VRF4API_METHOD DtVector rotationalVelocity() const;

   VRF4API_METHOD DtVector worldAcceleration() const;
   VRF4API_METHOD DtVector localAcceleration() const;
   VRF4API_METHOD DtVector relativeAcceleration() const;

};

#include "simObject.inl"