aggregateStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/entityStateComponent.h"
#include "vrfutil/rwFormationType.h"
#include "vrfutil/rwAggregateState.h"
#include "geometry/extent.h"

namespace makVrf
{
   struct DT_DLL_vrfStateData DtAggregateStateComponentData : public DtEntityStateComponentData
   {
      DtAggregateStateComponentData()
      : myFormation(DtOtherAggregateFormation)
      , myAggregateState(DtOtherAggregateState)
      {
      }

      DtAggregateStateComponentData(const DtAggregateStateComponentData& orig)
      : DtEntityStateComponentData(orig)
      , myFormationName(orig.myFormationName)
      , myAggregateState(orig.myAggregateState)
      , myFormation(orig.myFormation)
      {
      }

      DtAggregateStateComponentData operator=(const DtAggregateStateComponentData& rhs)
      {
         DtEntityStateComponentData::operator=(rhs);

         myFormationName = rhs.myFormationName;
         myFormation = rhs.myFormation;
         myAggregateState = rhs.myAggregateState;

         return *this;
      }

      DEFINE_ACCESSOR_MUTATOR(DtAggregateFormation, formation, Formation)
      DEFINE_ACCESSOR_MUTATOR(DtString, formationName, FormationName)
      DEFINE_ACCESSOR_MUTATOR(DtAggregateState, aggregateState, AggregateState)

   protected:
      DtAggregateFormation myFormation;
      DtString myFormationName;
      DtAggregateState myAggregateState;
   };

   class DT_DLL_vrfStateData DtAggregateStateComponent : public DtEntityStateComponent
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::AggregateStateComponent)

      DtAggregateStateComponent(DtStateData* storage)
      : DtEntityStateComponent(storage)
      {
      }

      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtString, formationName, FormationName)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtAggregateState, aggregateState, AggregateState)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtAggregateFormation, formation, Formation)
   };

   class DT_DLL_vrfStateData DtAggregateStateComponentNextFrame : public DtEntityStateComponentNextFrameTemplate<DtAggregateStateComponent>
   {
   public:
      DtAggregateStateComponentNextFrame(DtStateData* sd);

      const DtAggregateStateComponentData& aggregateFrameState() const { return myAggregateData; };
      DtAggregateStateComponentData& aggregateFrameState() { return myAggregateData; };

      const DtString& formationName() const;
      void setFormationName(const DtString&);

      const DtAggregateState& aggregateState() const;
      void setAggregateState(const DtAggregateState&);

      const DtAggregateFormation& formation() const;
      void setFormation(const DtAggregateFormation&);

   protected:
      DtAggregateStateComponentData myAggregateData;
   };

   class DT_DLL_vrfStateData DtAggregateStateComponentCurrentFrame : public DtEntityStateComponentCurrentFrameTemplate<DtAggregateStateComponent>
   {
   public:
      DtAggregateStateComponentCurrentFrame(DtStateData* sd);

      const DtAggregateStateComponentData& aggregateFrameState() const { return myAggregateData; };

      const DtString& formationName() const;
      const DtAggregateState& aggregateState() const;
      const DtAggregateFormation& formation() const;

   protected:
      friend class DtAggregateStateComponentImplementation;
      void advanceAggregateFrame(const DtAggregateStateComponentData& data)
      {
         myAggregateData = data;
      }

   protected:
      DtAggregateStateComponentData myAggregateData;
   };

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

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

      void updateDataStorage()
      {
         if (myNextFrameState.isWritable())
         {
            myCurrentFrameState.advanceAggregateFrame(myNextFrameState.aggregateFrameState());
            myCurrentFrameState.advanceFrame(myNextFrameState.frameState());
         }

         myCurrentFrameState.checkForUpdatedItems();
         myCurrentFrameState.emitComponentUpdated();
      }

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

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

      virtual void convertToRemote();

      virtual void convertToLocal();

      virtual void addAdditionalStateComponents() override;

      virtual bool forceAdvance() override;

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

   protected:
      DtAggregateStateComponentCurrentFrame myCurrentFrameState;
      DtAggregateStateComponentNextFrame myNextFrameState;
      LOM::WriteEntityRepository myWriteAggregateStateRepository;
   };

   typedef DtStateComponentCreator<DtAggregateStateComponentImplementation> DtAggregateStateComponentCreator;
}