WsfPlatform.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
// ****************************************************************************
// Updated by Infoscitex, a DCS Company
// ****************************************************************************
 
#ifndef WSFPLATFORM_HPP
#define WSFPLATFORM_HPP
 
#include "wsf_export.h"
 
#include <string>
#include <vector>
 
#include "UtEntity.hpp"
class UtInput;
class UtInputBlock;
namespace ut
{
namespace script
{
class Data;
}
} // namespace ut
class WsfArticulatedPart;
#include "WsfAuxDataEnabled.hpp"
#include "WsfCategoryList.hpp"
class WsfCommAddress;
#include "WsfComponent.hpp"
#include "WsfComponentList.hpp"
#include "WsfEvent.hpp"
class WsfFuel;
class WsfGroup;
#include "WsfGroupList.hpp"
class WsfMover;
class WsfNavigationErrors;
#include "WsfObject.hpp"
class WsfSinglePlatformObserver;
class WsfPlatformPart;
#include "WsfRandomVariable.hpp"
class WsfScenario;
#include "script/WsfScriptContext.hpp"
class WsfSignatureList;
class WsfSimulation;
#include "WsfStringId.hpp"
class WsfTrack;
#include "WsfTrackId.hpp"
#include "WsfTrackListFwd.hpp"
class WsfTrackManager;
#include "WsfTypes.hpp"
#include "WsfUniqueId.hpp"
 
namespace wsf
{
class Terrain;
}

class WSF_EXPORT WsfPlatform :
   public WsfObject,
   public WsfPlatformComponent,
   public WsfPlatformComponentList,
   public WsfUniqueId,
   public UtEntity,
   public WsfAuxDataEnabled
{
public:
   // So WsfSimulation can access protected/private methods that shouldn't be made public.
   friend class WsfSimulation;
   friend class WsfSimulationBase;

   enum OnBrokenAction
   {
      cON_BROKEN_REMOVE,
      cON_BROKEN_DISABLE,
      cON_BROKEN_MOVABLE_DISABLED
   };
 
   WsfPlatform(const WsfScenario& aScenario);
   ~WsfPlatform() override;


   WsfStringId   GetComponentName() const override { return GetNameId(); }
   WsfComponent* CloneComponent() const override { return Clone(); }
   const int*    GetComponentRoles() const override;
   void*         QueryInterface(int aRole) override;


   const char*      GetScriptClassName() const override;
   UtScriptContext* GetScriptAccessibleContext() const override;
 
   WsfPlatform* Clone() const override;
   void         AssignToSimulation(WsfSimulation* aSimulationPtr);
   virtual void CompleteLoad(WsfScenario& aScenario);
   bool         ProcessInput(UtInput& aInput) override;
   virtual bool Initialize(WsfSimulation* aSimulationPtr, double aSimTime);
   virtual bool Initialize2(WsfSimulation* aSimulationPtr, double aSimTime);

   void Update(double aSimTime)
   {
      if (mUpdateAllowed && // See DoUpdate for why this check is needed
          (!mUpdateLocked) && (mLastUpdateTime < aSimTime))
      {
         DoUpdate(aSimTime);
      }
   }
 
   void UpdateMultiThread(double aSimTime)
   {
      if (mUpdateAllowed && // See DoUpdate for why this check is needed
          (mLastUpdateTime < aSimTime))
      {
         DoUpdateMultiThread(aSimTime);
      }
   }

 
   void NotifyUpdate(double aSimTime)
   {
      if (mUpdateAllowed)
      {
         DoNotifyUpdate(aSimTime);
      }
   }
 
   void ExecuteScript(double aSimTime)
   {
      if (mUpdateAllowed)
      {
         DoExecuteScript(aSimTime);
      }
   }
 
   void SendQueuedMessages(double aSimTime)
   {
      if (mUpdateAllowed)
      {
         DoSendQueuedMessages(aSimTime);
      }
   }



   double GetCreationTime() const { return mCreationTime.LastDraw(); }
 
   bool InitializeCreationTime();
 
   void SetCreationTime(double aCreationTime);

   double GetLastUpdateTime() const { return mLastUpdateTime; }
 
   double GetSimTime() const;

   void SetUpdateLocked(bool aUpdateLocked) { mUpdateLocked = aUpdateLocked; }

   bool IsExternallyControlled() const { return mIsExternallyControlled; }

   void SetIsExternallyControlled(bool aIsExternallyControlled) { mIsExternallyControlled = aIsExternallyControlled; }

   bool IsExternallyMoved() const { return mIsExternallyMoved; }

   void SetIsExternallyMoved(bool aIsExternallyMoved) { mIsExternallyMoved = aIsExternallyMoved; }

   bool IsExternalShadow() const { return mIsExternalShadow; }

   void SetIsExternalShadow(bool aIsExternalShadow) { mIsExternalShadow = aIsExternalShadow; }

   bool IsIndestructible() const { return mIsIndestructible; }

   void SetIsIndestructible(bool aIsIndestructible) { mIsIndestructible = aIsIndestructible; }

   OnBrokenAction GetOnBrokenAction() const { return mOnBrokenAction; }

   void SetOnBrokenAction(OnBrokenAction aOnBrokenAction) { mOnBrokenAction = aOnBrokenAction; }

   void OnBrokenEvent(double aSimTime);

   bool IsBroken() const { return mIsBroken; }

   bool IsDeleted() const { return mIsDeleted; }

   bool IsInitialized() const { return mIsInitialized; }

   size_t GetIndex() const { return mIndex; }

   void SetIndex(size_t aIndex) { mIndex = aIndex; }

   WsfSimulation* GetSimulation() const { return mSimulationPtr; }

   const WsfScenario& GetScenario() const { return mScenario; }
 
   virtual void PlatformAdded(double aSimTime, WsfPlatform* aPlatformPtr);
 
   virtual void PlatformDeleted(WsfPlatform* aPlatformPtr);


   void GetLocationErrorWCS(double aLocationErrorWCS[3]) const;



   const std::string& GetSide() const { return mSide.GetString(); }
   void SetSide(WsfStringId aSide);
   WsfStringId GetSideId() const { return mSide; }



   const std::string& GetIcon() const { return mIcon.GetString(); }
   void SetIcon(WsfStringId aIcon) { mIcon = aIcon; }
   WsfStringId GetIconId() const { return mIcon; }



   const std::string& GetMarking() const { return mMarking.GetString(); }
   void SetMarking(WsfStringId aMarking) { mMarking = aMarking; }
   WsfStringId GetMarkingId() const { return mMarking; }



   WsfSpatialDomain GetSpatialDomain() const;
   void SetSpatialDomain(const WsfSpatialDomain& aSpatialDomain) { mSpatialDomain = aSpatialDomain; }


   bool ExecuteScript(double                               aSimTime,
                      WsfStringId                          aName,
                      UtScriptData&                        aScriptRetVal,
                      const std::vector<ut::script::Data>& aScriptArgs);
   bool ExecuteScript(double aSimTime, WsfStringId aName);
   void ExecuteScriptAtTime(double aTime, WsfStringId aName, const std::vector<ut::script::Data>& aScriptArgs);
   bool HasScript(WsfStringId aScriptNameId) const;

   WSF_DEPRECATED WsfScriptContext* GetContext() { return &mScriptContext; }
   WsfScriptContext&                GetScriptContext() { return mScriptContext; }


   WsfArticulatedPart* GetArticulatedPart(unsigned int aUniqueId) const;
   const WsfPlatformComponentList& GetComponents() const { return *this; }


   void SetMover(WsfMover* aMoverPtr);
   bool SwapMover(double aSimTime, WsfMover*& aNewMoverPtr, WsfMover*& aOldMoverPtr);

   WsfMover* GetMover() const { return mMoverPtr; }

   WsfFuel* GetFuel() const { return mFuelPtr; }



   wsf::Terrain& GetTerrain() const { return *mTerrainPtr; }
   double        GetHeightAboveTerrain();
   double        GetTerrainHeight();


   bool IsFalseTarget() const { return mIsFalseTarget; }
   void SetIsFalseTarget(bool aBoolState) { mIsFalseTarget = aBoolState; }



   double GetMass() const { return mEmptyMass + mFuelMass + mPayloadMass; }

   double GetEmptyMass() const { return mEmptyMass; }

   double GetPayloadMass() const { return mPayloadMass; }

   double GetFuelMass() const { return mFuelMass; }

   void SetFuelMass(double aValue) { mFuelMass = aValue; }

   void SetPayloadMass(double aValue) { mPayloadMass = aValue; }

   void SetEmptyMass(double aValue) { mEmptyMass = aValue; }




   WsfSignatureList& GetSignatureList()
   {
      if (mSignatureListPtr == nullptr)
      {
         CreateSignatureList();
      }
      return *mSignatureListPtr;
   }

   double GetHeight() const { return mHeight; }

   double GetLength() const { return mLength; }

   double GetWidth() const { return mWidth; }

   void SetLength(double aValue) { mLength = aValue; }

   void SetWidth(double aValue) { mWidth = aValue; }

   void SetHeight(double aValue) { mHeight = aValue; }

   unsigned int GetAppearance(unsigned int aLSB, unsigned int aNumBits) const;
   unsigned int GetAppearance() const { return mAppearanceWord; }
 
   void SetAppearance(unsigned int aLSB, unsigned int aNumBits, unsigned int aValue, bool aFromScript = false);
 
   bool ScriptOverride(unsigned int aLSB, unsigned int aNumBits) const;

   unsigned int GetCapabilities() const { return mCapabilitiesWord; }

   void SetCapabilities(unsigned int aCapabilitiesWord);

   float GetConcealmentFactor() const { return mConcealmentFactor; }
 
   void SetConcealmentFactor(float aConcealmentFactor);

   double GetDamageFactor() const { return mDamageFactor; }
 
   void SetDamageFactor(double aDamageFactor);
 
   void Comment(const double aTime, const std::string& aString);



   bool IsStopped() const;
   bool IsPaused() const;
   bool IsExtrapolating() const;


   const WsfTrackId&  GetNextTrackId();
   WsfLocalTrackList& GetMasterTrackList();
   WsfTrackList&      GetMasterRawTrackList();
   WsfTrackManager&   GetTrackManager();



   const WsfCategoryList& GetCategories() const { return mCategories; }
   void                   AddCategory(WsfStringId aCategoryId);
   bool                   IsCategoryMember(WsfStringId aCategoryId) const;



   const WsfGroupList& GetGroups() const { return mGroups; }
   void                JoinGroup(WsfGroup* aGroupPtr);
   void                LeaveGroup(WsfGroup* aGroupPtr);
   bool                IsGroupMember(WsfStringId aGroupId);


   void AttachObserver(WsfSinglePlatformObserver* aObserverPtr);
   void DetachObserver(WsfSinglePlatformObserver* aObserverPtr);
   void NotifyDeleted(double aSimTime);
   void NotifyDeleting(double aSimTime);


   void ProcessInputBlock(UtInputBlock& aInputBlock, bool aLoadingType);



   void SetBroken() { mIsBroken = true; }

   void SetDeleted(bool aDeleted = true) { mIsDeleted = aDeleted; }
 
protected:
   WsfPlatform(const WsfPlatform& aSrc);
 
   virtual void DoUpdate(double aSimTime);
   virtual void DoUpdateMultiThread(double aSimTime);
   virtual void DoMoverUpdate(double aSimTime);
   virtual void DoNotifyUpdate(double aSimTime);
   virtual void DoExecuteScript(double aSimTime);
   virtual void DoSendQueuedMessages(double aSimTime);


   void ComponentAdded(WsfComponent* aComponentPtr) override;
   void ComponentDeleted(WsfComponent* aComponentPtr) override;
 
private:
   WsfPlatform& operator=(const WsfPlatform& aRhs) = delete;


   void CreateSignatureList();
   void UpdatePersistentPointers(WsfComponent* aComponentPtr, bool aIsBeingAdded);
 
   const WsfScenario& mScenario;
   WsfSimulation*     mSimulationPtr = nullptr;

   size_t mIndex = 0;
 
   WsfStringId mSide    = nullptr;
   WsfStringId mIcon    = nullptr;
   WsfStringId mMarking = nullptr;

   WsfSpatialDomain mSpatialDomain = WSF_SPATIAL_DOMAIN_UNKNOWN;
 
   OnBrokenAction mOnBrokenAction = cON_BROKEN_REMOVE;

   WsfRandomVariable mCreationTime   = {0.0, WsfRandomVariable::cNON_NEGATIVE};
   double            mLastUpdateTime = -1.0;
 
   // Boolean flags are packed into an integer here
   union
   {
      struct
      {
         bool mIsInitialized : 1;
         bool mIsIndestructible : 1;
         bool mIsBroken : 1;
         bool mIsDeleted : 1;
         bool mUpdateAllowed : 1;
         bool mUpdateLocked : 1;
         bool mIsExternallyControlled : 1;
         bool mIsExternallyMoved : 1;
         bool mIsExternalShadow : 1;
         bool mIsFalseTarget : 1;
         bool mInputAltAGL : 1;
         bool mHasOnUpdateScript : 1;
         bool mInitPass : 1;
      };
      unsigned int mFlags;
   };
 
   mutable WsfTrackManager* mMasterTrackManagerPtr = nullptr; 
   WsfSignatureList*        mSignatureListPtr      = nullptr; 
   WsfMover*                mMoverPtr              = nullptr; 
   WsfFuel*                 mFuelPtr               = nullptr; 
   WsfNavigationErrors*     mNavErrorPtr           = nullptr; 
   WsfScriptContext         mScriptContext;                   
   wsf::Terrain*            mTerrainPtr = nullptr;            
   WsfCategoryList          mCategories;
   WsfGroupList             mGroups;

   WsfTrackId mNextTrackId;

   WsfVariable<double> mHeight = 0.0;
   WsfVariable<double> mLength = 0.0;
   WsfVariable<double> mWidth  = 0.0;

   WsfVariable<double> mEmptyMass   = 0.0; // Platform empty mass (fixed)
   WsfVariable<double> mFuelMass    = 0.0; // Platform fuel mass (variable)
   WsfVariable<double> mPayloadMass = 0.0; // Payload mass (variable)
 
   double mDamageFactor      = 0.0;
   float  mConcealmentFactor = 0.0F;

   unsigned int mAppearanceWord           = 0;
   unsigned int mAppearanceWordScriptMask = 0;
   unsigned int mCapabilitiesWord         = 0;
 
   std::vector<WsfSinglePlatformObserver*> mObservers;
};
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(WsfPlatform, cWSF_COMPONENT_PLATFORM)
 
#endif