DtEntityStateInterceptor.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2020 VT MAK
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include <vrvVrl/DtBaseEntityStateInterceptor.h>
#include <vrvVrl/DtPartCollectionInterceptor.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vlutil/vlTime.h>
#include <vl/globalObjectDesignator.h>
#include <matrix/vlVector.h>
#include <matrix/vlTaitBryan.h>
#include <vlpi/disEnums.h>
#include <vlpi/entityType.h>

class DtStateRepository;
class DtEntityStateRepository;
class DtArticulatedPartCollection;

namespace makVrv
{

   namespace DT_PROTOCOL_NAMESPACE
   {

      class DtVrlinkConnection;
      class DtVrlinkEntityStateListener;


      template <typename StateRepClass>
      class DtEntityStateInterceptor : public StateRepClass, public DtBaseEntityStateInterceptor
      {
      public:

         DtEntityStateInterceptor(DtVrlinkEntityStateListener* listener);

         virtual ~DtEntityStateInterceptor();

      private:
         //\throws DtCorrutedState this class is not copyable.
         DtEntityStateInterceptor(const DtEntityStateInterceptor& orig);

         //\throws DtCorrutedState this class is not copyable.
         DtEntityStateInterceptor& operator=(const DtEntityStateInterceptor& orig);

         //\throws DtCorrutedState this class is not copyable.
         virtual DtStateRepository* clone(bool copy = false) const;
      public:

         //@name DtBaseEntityStateRepository functions

         virtual void setAll(
            const DtVector& loc,
            const DtVector32& vel,
            const DtTaitBryan& ori,
            const DtVector32& acc,
            const DtVector32& rotVel,
            DtTime curTime);

         virtual void setLocation(const DtVector & location, DtTime aTime);

         virtual void setVelocity(const DtVector32 & Velocity, DtTime aTime);

         virtual void setAcceleration(const DtVector32 & Acceleration, DtTime aTime);

         virtual void setOrientation(const DtTaitBryan& orient, DtTime aTime);

         virtual void setRotationalVelocity(const DtVector32 & BodyRates, DtTime aTime);

         virtual void setAlgorithm(DtDeadReckonTypes alg);

         virtual void setHostGlobalId( const DtGlobalObjectDesignator& id );

         virtual void clearHostGlobalId();

         virtual void setRelativeLocation(const DtVector & location, DtTime aTime);

         virtual void setRelativeVelocity(const DtVector32 & Velocity, DtTime aTime);

         virtual void setRelativeAcceleration(const DtVector32 & Acceleration,
         DtTime aTime);

         virtual void setRelativeOrientation(const DtTaitBryan& orient,
         DtTime aTime);

         virtual void setRelativeRotationalVelocity(const DtVector32 & BodyRates,
         DtTime aTime);

         virtual void setRelativeFrozen(bool onOff);

         virtual void setRelativeAlgorithm(DtDeadReckonTypes alg);

         virtual void setRelativePosition( const DtVector & newVal );

         /*

         virtual void setNature( const DtNature newVal );

         virtual void setPartPosition( const DtPosition newVal );

         virtual void setStationName( const DtStationName newVal );

         virtual void setStationNumber( const DtU16 newVal );

         virtual void setRange( const DtFloat32 newVal );

         virtual void setBearing( const DtFloat32 newVal );

         */
         virtual void setEntityType(const DtEntityType& type);
         /*
         virtual void setFederateId(const DtFederateId& id);


         //@name DtEntityStateRepository functions

         */

#ifdef DtHLA
         virtual void setEntityId(const DtEntityIdentifier& id);
#endif
         virtual void setForceId(DtForceType force);

         /*
         virtual void setGuise(const DtEntityType& type);
*/
         virtual void setFrozen(bool onOff);
/*
         virtual void setMarkingCharSet(int charSet);
   */
         virtual void setMarkingText(const char* text);
   /*

         virtual void setPowerPlantOn(bool onOff);
   */
         virtual void setDamageState(DtDamageState s);

         virtual void setEngineSmokeOn(bool onOff);

         virtual void setFlamesPresent(bool onOff);
         /*

         virtual void setHasFuelSupplyCap(bool onOff);

         virtual void setHasRecoveryCap(bool onOff);

         virtual void setHasRepairCap(bool onOff);

         virtual void setHatchState(DtHatchState s);

         virtual void setImmobilized(bool onOff);
   */
         virtual void setLifeformState(DtLifeformState s);

         virtual void setLightState(DtLightType s, bool onOff);

   /*

         virtual void setLightState(DtLightState s);

         virtual void setDensity(DtDensityType dens);

         virtual void setRampDeployed(bool onOff);
   */
         virtual void setSmokePlumePresent(bool onOff);
   /*
         virtual void setTentDeployed(bool onOff);

         */
         virtual void setTrailState(DtTrailState s);
         /*

         virtual void setCamouflageType(DtCamouflageType type);

         virtual void setFirePowerDisabled(bool onOff);

         virtual void setIsConcealed(bool onOff);

         virtual void setAfterburnerOn(bool onOff);

         virtual void setHasAmmunitionSupplyCap(bool onOff);

         virtual void setLauncherRaised(bool onOff);

         virtual void setLauncherFlashPresent(bool onOff);
   */
         virtual void setPrimaryWeaponState(DtWeaponState s);
   /*
         virtual void setSecondaryWeaponState(DtWeaponState s);

         virtual void setComplianceState(DtComplianceState s);

         virtual void setAntennaRaised(bool upDown);

         virtual void setMissionKill(bool yesNo);

         virtual void setInternalHeatSource(bool onOff);

         virtual void setMaskedCloaked(bool onOff);
   */
         //We need this for DIS as individual functions are not called.
   #if DtDIS
         virtual void setAppearance(DtU32 app);
   #endif

         virtual void setAppearanceAttribute(const DtAppearAttribute attr,
            const DtAppearAttrVal val);

         /*

         virtual void setInfraRedSigRepIndex(DtU16 value);
         virtual DtU16 infraRedSigRepIndex() const;

         virtual void setAcousticSigRepIndex(DtU16 value);
         virtual DtU16 acousticSigRepIndex() const;

         virtual void setRadarSigRepIndex(DtU16 value);
         virtual DtU16 radarSigRepIndex() const;

         virtual void setMeasuredSpeed(DtU16 value);

         virtual void setCapabilities(DtU32 cap);
         */

         virtual void setDiGuyAction( const DtString& val, bool paused, double speed,
            bool usePositioning, const DtVector& offset );

         virtual void setDiGuyAppearance( const DtString& val );
         virtual void setDiGuyHeadAppearance( const DtString& val );
         virtual void setDiGuyItemAppearance( const DtString& val );


         virtual void setDiGuyAppearanceNoPropagation( const DtString& val );
         virtual void setDiGuyHeadAppearanceNoPropagation( const DtString& val );
         virtual void setDiGuyItemAppearanceNoPropagation( const DtString& val );
         virtual void setDiGuyTypeNoPropagation( const DtString& val );
         virtual void setDiGuyBodyWeightNoPropagation( DtFloat64 val );
         virtual void setDiGuyActionNoPropagation( const DtString& val, bool paused,
            double speed, bool usePositioning, const DtVector& offset );


         virtual void setDiGuyArc( const std::vector<char>& val );
         virtual void setDiGuyType( const DtString& val );
         virtual void setDiGuyParent( const DtEntityIdentifier& val );

         virtual DtArticulatedPartCollection* artPartList();

         virtual void setDiGuyCharacterScale( const DtVector& scale );

         virtual void setDiGuyStateRepository( DtDIGuyObjectStateRepository* diGuyStateRep );

      protected:

         DtVrlinkEntityStateListener* myListener;
         double myBodyWeight;

      };

   }
}