entityStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/simulatedObjectStateComponent.h"
#include "vrfStateData/stateData.h"
#include <vlpi/disEnums.h>
#include <legionStandardOM/sets/writeEntityRepository.hpp>
#include "legionStandardOM/sets/readEntityRepository.hpp"
#include "legionDataStore/view.h"
#include <tbb/spin_mutex.h>

namespace LOM
{
   class ReadEntityRepository;
}

class DtAppearance;

namespace makVrf
{
   struct DT_DLL_vrfStateData DtEntityStateComponentData
   {
      typedef unsigned long long SimStateID;

      DtEntityStateComponentData()
      : myUUID(DtUUID::nullUUID())
      , myIsLocal(false)
      {};

      DtEntityStateComponentData(const DtEntityStateComponentData& orig)
      : myGlobalId(orig.myGlobalId)
      , myUUID(orig.myUUID)
      , myMarkingText(orig.myMarkingText)
      , myEntityId(orig.myEntityId)
      , myIsLocal(orig.myIsLocal)
      {
      }

      DtEntityStateComponentData& operator=(const DtEntityStateComponentData& rhs)
      {
         myGlobalId = rhs.myGlobalId;
         myUUID = rhs.myUUID;
         myEntityId = rhs.myEntityId;
         myMarkingText = rhs.myMarkingText;
         myIsLocal = rhs.myIsLocal;

         return *this;
      }

      DEFINE_ACCESSOR_MUTATOR(DtString, globalId, GlobalId)
      DEFINE_ACCESSOR_MUTATOR(DtEntityIdentifier, entityId, EntityId)
      DEFINE_ACCESSOR_MUTATOR(DtUUID, uuid, UUID)
      DEFINE_ACCESSOR_MUTATOR(DtString, markingText, MarkingText)
      DEFINE_ACCESSOR_MUTATOR(bool, isLocal, IsLocal)

   protected:
      DtString myGlobalId;
      DtString myMarkingText;
      DtEntityIdentifier myEntityId;
      DtUUID myUUID;
      bool myIsLocal;
   };

   class DT_DLL_vrfStateData DtEntityStateComponent : public DtSimulatedObjectStateComponent
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::EntityStateComponent)

      DtEntityStateComponent(DtStateData* storage)
      : DtSimulatedObjectStateComponent(storage)
      , myUUIDColumn(0xFFFFFFFF)
      , myIsBackgroundEntityColumn(0xFFFFFFFF)
      {
      }

      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, isBackgroundEntity, IsBackgroundEntity)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(UInt32, capabilities, Capabilities)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtEntityType, guise, Guise)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtUUID, superior, Superior)

      virtual const std::set<DtUUID> attachments() const { throw DtUnimplementedMethod("std::set<DtUUID> attachments() is not implemented for this class."); };
      virtual void setEntityType(const DtObjectType& ot) { throw DtUnimplementedMethod("void setEntityType(const DtObjectType& ot) is not implemented for this class."); };
      virtual void addAttachment(const DtUUID&) { throw DtUnimplementedMethod("void addAttachment(const DtUUID&) is not implemented for this class."); };
      virtual void removeAttachment(const DtUUID&) { throw DtUnimplementedMethod("void removeAttachment(const DtUUID&) is not implemented for this class."); };

      mutable boost::signals2::signal<void (int oldState, int newState, makVrf::SimStateID)> signal_damageStateChanged;
      mutable boost::signals2::signal<void (const DtFrameStateInterface*)> signal_attachmentsChanged;
      mutable boost::signals2::signal<void (const DtUUID& oldSuperior, const DtUUID& newSuperior)> signal_superiorChanged;

   protected:
      UInt32 myUUIDColumn;
      UInt32 myIsBackgroundEntityColumn;
   };

   template <typename T_BaseComponent>
   class DtEntityStateComponentNextFrameTemplate : public T_BaseComponent
   {
   public:
      DtEntityStateComponentNextFrameTemplate(DtStateData*);
      virtual ~DtEntityStateComponentNextFrameTemplate();

      const DtEntityStateComponentData& frameState() const { return this->myData; };
      DtEntityStateComponentData& frameState() { return this->myData; };
   
      const bool& isLocal() const;
      void setIsLocal(const bool&);
   
      const DtString& globalId() const;
      void setGlobalId(const DtString&);

      const DtUUID& uuid() const;
      void setUUID(const DtUUID&);

      const bool isBackgroundEntity() const;
      void setIsBackgroundEntity(const bool&);

      const DtString& markingText() const;
      void setMarkingText(const DtString&);

      const DtForceType forceType() const;
      void setForceType(const DtForceType&);

      const UInt32 appearanceBits() const;
      void setAppearanceBits(const UInt32&);

      const DtEntityType entityType() const { return DtEntityType(objectType()); };
      const DtObjectType objectType() const;
      void setEntityType(const DtObjectType&);
      void setEntityType(const DtEntityType& t) { setEntityType(DtObjectType(t.kind() == 11 ? 3 : 1, t)); };

      const DtEntityIdentifier& entityId() const;
      void setEntityId(const DtEntityIdentifier&);

      const UInt32 capabilities() const;
      void setCapabilities(const UInt32&);

      const DtEntityType guise() const;
      void setGuise(const DtEntityType&);

      const DtUUID& superior() const;
      void setSuperior(const DtUUID&);

      virtual void setAppearance(const DtAppearance& app);

      virtual void makeWritable();

      virtual void makeReadOnly();
      
   protected:
      LOM::WriteEntityRepository myWriteEntityStateRepository;
      DtStateData* myStateData;
      DtUUID mySuperior;
      mutable DtEntityStateComponentData myData;
   };

   typedef DtEntityStateComponentNextFrameTemplate<DtEntityStateComponent> DtEntityStateComponentNextFrame;

   template <typename T_BaseComponent>
   class DtEntityStateComponentCurrentFrameTemplate : public T_BaseComponent
   {
   public:
      DtEntityStateComponentCurrentFrameTemplate(DtStateData*);
      virtual ~DtEntityStateComponentCurrentFrameTemplate();

      const DtEntityStateComponentData& frameState() const { return this->myData; };
   
      const bool& isLocal() const;
      const DtString& globalId() const;
      const DtUUID& uuid() const;
      const DtString& markingText() const;
      const DtForceType forceType() const;
      const DtEntityType entityType() const { return DtEntityType(objectType()); };
      const DtObjectType objectType() const;
      const DtEntityIdentifier& entityId() const;
      const UInt32 appearanceBits() const;
      const bool isBackgroundEntity() const;
      const UInt32 capabilities() const;
      const DtEntityType guise() const;

      const DtUUID& superior() const;

      void addAttachment(const DtUUID&);
      void removeAttachment(const DtUUID&);
      const std::set<DtUUID> attachments() const;

      bool checkForUpdatedItems();

   protected:
      const DtUUID _uuid() const;
      const DtString _markingText() const;
      const DtEntityIdentifier _entityId() const;

      bool checkEntityIdChanged();
      bool checkUUIDChanged();
      bool checkForceChanged();
      bool checkMarkingTextChanged();
      bool checkDamageStateChanged();

      void handleDataUpdated(const std::vector<UInt32>& attributesUpdated);
      void completeSetup();

      friend class DtEntityStateComponentImplementation;
      void advanceFrame(const DtEntityStateComponentData& data)
      {
         this->myData = data;
      }

   protected:
      friend class DtStateDataManager;
      void setSuperior(const DtUUID&);

   protected:
      LOM::ReadEntityRepository myReadEntityStateRepository;
      DtStateData* myStateData;
      DtUUID mySuperior;
      int myForceId;
      int myDamageState;
      unsigned int myCallbackHandle;

      std::set<DtUUID> myAttachments;
      mutable tbb::spin_rw_mutex myAttachmentsMutex;
      boost::signals2::scoped_connection myCompleteSetupConnection;
      tbb::spin_mutex myCompleteSetupMutex;
      DtEntityStateComponentData myData;
   };

   typedef DtEntityStateComponentCurrentFrameTemplate<DtEntityStateComponent> DtEntityStateComponentCurrentFrame;

   class DT_DLL_vrfStateData DtEntityStateComponentImplementation : public DtDoubleBufferedStateComponent<DtEntityStateComponent>
   {
   public:
      DtEntityStateComponentImplementation(DtStateData* sd);
      virtual ~DtEntityStateComponentImplementation();

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

      void updateDataStorage();

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

      static void addAdditionalTableColumns(Legion::SimulationDatabase*);

      virtual void initializeFromParameters(const DtVrfObjectParameters* params);

      Legion::WriteStateInstance writeStateInstance() override { return myWriteEntityStateRepository; };

      virtual void convertToRemote();

      virtual void convertToLocal();

      virtual void addAdditionalStateComponents() override;

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

   protected:
      DtEntityStateComponentCurrentFrame myCurrentFrameState;
      DtEntityStateComponentNextFrame myNextFrameState;
      LOM::WriteEntityRepository myWriteEntityStateRepository;
   };

   typedef DtStateComponentCreator<DtEntityStateComponentImplementation> DtEntityStateComponentCreator;
}

#define _ENTITY_STATE_COMPONENT 1
#include "vrfStateData/entityStateComponent.inl"