entityLocationStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/locationStateComponent.h"
#include <legionStandardOM/sets/readEntityRepository.hpp>
#include <legionStandardOM/sets/writeEntityRepository.hpp>
#include <legionStandardOM/sets/readEmbarkedEntityRepository.hpp>
#include <legionStandardOM/sets/writeEmbarkedEntityRepository.hpp>

#include <tbb/mutex.h>
#include <tbb/spin_rw_mutex.h>
#include <boost/signals2.hpp>

namespace LOM
{
   class ReadEntityRepository;
}

class Coordinate_System;

namespace makVrf
{
   class DtStateDataManager;
   struct DtEntityLocationStateComponentData
   {
      DtEntityLocationStateComponentData()
      : mySpatiallyFrozen(false)
      , myHostGlobalId(DtUUID::nullUUID())
      , myStationName(DtStationName::DtOnStation_XYZ)
      , myNeedsEmbarkCheck(false)
      {};

      DtEntityLocationStateComponentData(const DtEntityLocationStateComponentData& orig)
      : myHostGlobalId(orig.myHostGlobalId)
      , mySpatiallyFrozen(orig.mySpatiallyFrozen)
      , myThresholder(orig.myThresholder)
      , myStationName(orig.myStationName)
      , myNeedsEmbarkCheck(orig.myNeedsEmbarkCheck)
      {
      }

      DtEntityLocationStateComponentData& operator=(const DtEntityLocationStateComponentData& rhs)
      {
         myHostGlobalId = rhs.myHostGlobalId;
         myNeedsEmbarkCheck = rhs.myNeedsEmbarkCheck;
         mySpatiallyFrozen = rhs.mySpatiallyFrozen;
         myThresholder = rhs.myThresholder;
         myStationName = rhs.myStationName;

         return *this;
      }

      DEFINE_ACCESSOR_MUTATOR(DtUUID, hostGlobalId, HostGlobalId)
      DEFINE_ACCESSOR_MUTATOR(bool, spatiallyFrozen, SpatiallyFrozen)
      DEFINE_REF_ACCESSORS(DtThresholder, thresholder, Thresholder)
      DEFINE_ACCESSOR_MUTATOR(DtStationName, stationName, StationName)
      DEFINE_ACCESSOR_MUTATOR(bool, needsEmbarkCheck, NeedsEmbarkCheck)

   protected:
      DtUUID myHostGlobalId;
      bool mySpatiallyFrozen;
      DtThresholder myThresholder;
      DtStationName myStationName;
      bool myNeedsEmbarkCheck;
   };

   class DT_DLL_vrfStateData DtEntityLocationStateComponentInterface : public DtLocationStateComponent
   {
   public:
      DtEntityLocationStateComponentInterface(DtStateData* storage)
      : DtLocationStateComponent(storage)
      {
      }

      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, spatiallyFrozen, SpatiallyFrozen)
      UNDEFINED_RETURNREF_ACCESSORS(DtThresholder, thresholder)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtVector, velocity, Velocity)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtVector, acceleration, Acceleration)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtVector, rotationalVelocity, RotationalVelocity)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtDeadReckonTypes, algorithm, Algorithm)
      UNDEFINED_RETURNVALUE_ACCESSOR(DtDeadReckonTypes, deadReckoningAlgorithm)

      UNDEFINED_RETURNREF_ACCESSOR(DtVector, worldVelocity)
      UNDEFINED_RETURNREF_ACCESSOR(DtVector, worldAcceleration)
      UNDEFINED_RETURNVALUE_ACCESSOR(double, worldSpeed)

      UNDEFINED_RETURNREF_ACCESSOR(DtVector, localVelocity)
      UNDEFINED_RETURNREF_ACCESSOR(DtVector, localAcceleration)
      UNDEFINED_RETURNVALUE_ACCESSOR(double, localSpeed)

      UNDEFINED_RETURNREF_ACCESSOR(DtVector, relativeVelocity)
      UNDEFINED_RETURNREF_ACCESSOR(DtVector, relativeAcceleration)
      UNDEFINED_RETURNVALUE_ACCESSOR(DtVector, bodyVelocity)
      UNDEFINED_RETURNREF_ACCESSOR(DtVector, parentVelocity)
      UNDEFINED_RETURNREF_ACCESSOR(DtVector, parentAcceleration)
      UNDEFINED_RETURNVALUE_ACCESSOR(DtStationName, parentStationName)

      UNDEFINED_METHOD(void, setRelativeVelocity, const DtVector&)
      UNDEFINED_METHOD(void, setParentAcceleration, const DtVector&)
      UNDEFINED_METHOD(void, setParentVelocity, const DtVector&)
      UNDEFINED_METHOD(void, setParentStationName, DtStationName)
      UNDEFINED_METHOD(void, setRelativeAcceleration, const DtVector&)
      UNDEFINED_METHOD(void, setLocalVelocity, const DtVector&)
      UNDEFINED_METHOD(void, setLocalAcceleration, const DtVector&)
      UNDEFINED_METHOD(void, setLocalSpeed, double)
      UNDEFINED_METHOD(void, setWorldVelocity, const DtVector&)
      UNDEFINED_METHOD(void, setWorldAcceleration, const DtVector&)
   };

   class DT_DLL_vrfStateData DtEntityLocationStateComponent : public DtEntityLocationStateComponentInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::EntityLocationStateComponent)

      DtEntityLocationStateComponent(DtStateData* storage)
      : DtEntityLocationStateComponentInterface(storage)
      {
      }
   };

   class DT_DLL_vrfStateData DtEntityLocationStateComponentNextFrame : public DtEntityLocationStateComponent
   {
   public:
      DtEntityLocationStateComponentNextFrame(DtStateData*);
      virtual ~DtEntityLocationStateComponentNextFrame();

      const DtEntityLocationStateComponentData& frameState() const { return myData; };
      DtEntityLocationStateComponentData& frameState() { return myData; };
   
      const DtUUID& hostGlobalId() const;
      void setHostGlobalId( const DtUUID& id);
      const int objectAttachMode() const;

      void setAlgorithm(const DtDeadReckonTypes& alg);
      const DtDeadReckonTypes algorithm() const;
      const DtDeadReckonTypes deadReckoningAlgorithm() const { return algorithm(); };

      const bool frozen() const;
      void setFrozen(const bool&);

      const DtVector location() const;
      void setLocation(const DtVector&);

      const DtVector velocity() const;
      void setVelocity(const DtVector&);

      const DtVector acceleration() const;
      void setAcceleration(const DtVector&);

      const DtTaitBryan orientation() const;
      void setOrientation(const DtTaitBryan&);

      const DtVector& rotationalVelocity() const;
      void setRotationalVelocity(const DtVector&);

      const bool locationChanged() const;

      const DtVector& worldPosition() const;
      const DtVector& relativePosition() const;
      const DtVector& parentPosition() const;
      const DtStationName parentStationName() const;
      const DtVector& localPosition() const;
      const DtVector& worldVelocity() const;
      const DtVector& localVelocity() const;
      const DtVector& worldAcceleration() const;
      const DtVector& localAcceleration() const;
      const DtTaitBryan& worldOrientation() const;
      const DtTaitBryan& topographicOrientation() const;
      const DtTaitBryan& parentOrientation() const;
      const DtTaitBryan& localOrientation() const;
      const DtDcm& worldOrientationMatrix() const;
      const bool localPositionIsValid() const;

      const bool spatiallyFrozen() const;
      void setSpatiallyFrozen(const bool&);

      const DtThresholder& thresholder() const;
      DtThresholder& thresholder();

      const double heading() const;
      const double pitch() const;
      const double roll() const;

      const double localSpeed() const;

      const double worldSpeed() const;

      const DtDcm& parentOrientationMatrix() const;
      void setLocalOrientationMatrix(const DtDcm&);
      void setLocalOrientation(const DtTaitBryan&);
      void setLocalOrientationWrtDatabase(const DtTaitBryan&);

      const DtDcm& localOrientationMatrix() const;
      const DtTaitBryan& localOrientationWrtDatabase() const;

      void setRelativeVelocity(const DtVector&);
      void setRelativeAcceleration(const DtVector&);
      void setParentVelocity(const DtVector&);
      void setParentAcceleration(const DtVector&);
      void setLocalVelocity(const DtVector&);
      void setLocalAcceleration(const DtVector&);
      void setLocalPosition(const DtVector&);
      void setWorldPosition(const DtVector&);
      void setWorldVelocity(const DtVector&);
      void setWorldAcceleration(const DtVector&);
      void setWorldOrientation(const DtTaitBryan&);
      void setParentOrientation(const DtTaitBryan&);
      void setParentPosition(const DtVector&);
      void setParentStationName(DtStationName);
      void setWorldOrientationMatrix(const DtDcm&);
      void setLocalSpeed(double);
      const DtRwVrfKinematicState& kinematicState() const;

      const DtVector& relativeVelocity() const;
      const DtVector& relativeAcceleration() const;
      const DtVector& parentVelocity() const;
      const DtVector& parentAcceleration() const;
      const DtVector bodyVelocity() const;

      void setCoordinateSystem(const Coordinate_System* cs);
      void setKinematicState(const DtRwVrfKinematicState&);

      virtual void refreshKinematicState(const DtEntityLocationStateComponent&);

      virtual void makeWritable();

      virtual void makeReadOnly();
      void slot_hostDestroyed();

      bool needsEmbarkCheck();
      void clearNeedsEmbarkCheck();

   protected:
      LOM::WriteEntityRepository myWriteEntityStateRepository;
      DtStateData* myStateData;
      DtRwVrfKinematicState* myKinematicState;
      DtStateDataManager* myStateDataManager;

      mutable tbb::spin_rw_mutex myWriteStateMutex;
      DtEntityLocationStateComponentData myData;
      boost::signals2::scoped_connection myHostDeletedConnection;
      bool myFirstVelocitySet;
   };

   class DT_DLL_vrfStateData DtEntityLocationStateComponentCurrentFrame : public DtEntityLocationStateComponent
   {
   public:
      DtEntityLocationStateComponentCurrentFrame(DtStateData*);
      virtual ~DtEntityLocationStateComponentCurrentFrame();

      const DtEntityLocationStateComponentData& frameState() const { return myData; };
   
      const DtUUID& hostGlobalId() const;
      const int objectAttachMode() const;

      const DtRwVrfKinematicState& kinematicState() const;
      const bool frozen() const;
      const bool localPositionIsValid() const;

      const DtVector location() const;
      const DtVector velocity() const;
      const DtVector acceleration() const;
      const DtTaitBryan orientation() const;

      const DtVector& rotationalVelocity() const;
      const double heading() const;
      const double pitch() const;
      const double roll() const;
      const double localSpeed() const;
      const double worldSpeed() const;

      const DtDeadReckonTypes algorithm() const;
      const DtDeadReckonTypes deadReckoningAlgorithm() const { return algorithm(); };
      const bool spatiallyFrozen() const;
      const DtThresholder& thresholder() const;

      const DtVector& worldPosition() const;
      const DtVector& worldVelocity() const;
      const DtVector& worldAcceleration() const;
      const DtVector& relativePosition() const;
      const DtVector& parentPosition() const;
      const DtStationName parentStationName() const;
      const DtVector& relativeVelocity() const;
      const DtVector& relativeAcceleration() const;
      const DtVector& parentVelocity() const;
      const DtVector& parentAcceleration() const;
      const DtVector bodyVelocity() const;
      const DtTaitBryan& worldOrientation() const;
      const DtTaitBryan& topographicOrientation() const;
      const DtTaitBryan& parentOrientation() const;

      const DtDcm& parentOrientationMatrix() const;

      const DtVector& localPosition() const;
      const DtVector& localVelocity() const;
      const DtVector& localAcceleration() const;
      const DtTaitBryan& localOrientation() const;

      const DtDcm& worldOrientationMatrix() const;
      const DtDcm& localOrientationMatrix() const;
      const DtTaitBryan& localOrientationWrtDatabase() const;

      const bool locationChanged() const;

      void setCoordinateSystem(const Coordinate_System* cs);
      void refreshKinematicState() const;

   protected:
      friend class DtEntityLocationStateComponentImplementation;

      void setLocationChanged(bool);
      virtual void needsKinematicStateRefresh();
      virtual void needsEmbarkedCheck();
      void advanceFrame(const DtEntityLocationStateComponentData& data)
      {
         myData = data;
      }

   protected:
      void handleDataUpdated(const std::vector<UInt32>& attributesUpdated);
      virtual void updateSpatial();
      const DtVector _rotationalVelocity() const;

   protected:
      LOM::ReadEntityRepository myReadEntityStateRepository;
      bool myLocationChanged;
      DtStateDataManager* myStateDataManager;

      mutable tbb::mutex myKinematicStateMutex;
      mutable bool myNeedsKinematicStateRefresh;
      mutable DtRwVrfKinematicState* myKinematicState;
      DtStateData* myStateData;
      unsigned int myCallbackHandle;
      DtEntityLocationStateComponentData myData;
      unsigned int myEmbarkedCallbackHandle;
      bool myNeedsEmbarkedCheck;
   };

   class DT_DLL_vrfStateData DtEntityLocationStateComponentImplementation : public DtDoubleBufferedStateComponent<DtEntityLocationStateComponent>
   {
   public:
      DtEntityLocationStateComponentImplementation(DtStateData* sd);

      bool isDoubleBuffered() { return true; };
      const DtFrameStateInterface* currentFrameState() const { return &myCurrentFrameState; }
      virtual DtFrameStateInterface* nextFrameState() { return &myNextFrameState; };
      virtual const DtFrameStateInterface* nextFrameState() const { return &myNextFrameState; };

      virtual void setCoordinateSystem(const Coordinate_System*);

      virtual bool forceAdvance();

      void updateDataStorage();

      void updateStateData(DtStateData* sd)
      {
         myCurrentFrameState.updateStateData(sd);
         myNextFrameState.updateStateData(sd);
      }

      virtual void aboutToBeDeleted() override
      {
         DtDoubleBufferedStateComponent<DtEntityLocationStateComponent>::aboutToBeDeleted();
         myCurrentFrameState.aboutToBeDeleted();
         myNextFrameState.aboutToBeDeleted();
      }

      virtual void initializeFromParameters(const DtVrfObjectParameters* params);

   protected:
      virtual void hostWasDeleted();

   protected:
      DtEntityLocationStateComponentCurrentFrame myCurrentFrameState;
      DtEntityLocationStateComponentNextFrame myNextFrameState;
      DtEntityLocationStateComponent* myLastAttachedToLocationStateComponent;
      DtStateData* myLastAttachedTo;
      boost::signals2::scoped_connection myHostWasDeletedConnection;
   };

   typedef DtStateComponentCreator<DtEntityLocationStateComponentImplementation> DtEntityLocationStateComponentCreator;
}