remoteObjectManager.h

Go to the documentation of this file.

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

#pragma once

#include "legionNetworkInterface/legionNetworkInterfaceDefines.h"
#include "vrfStateData/stateData.h"
#include "vrfStateData/stateDataManager.h"
#include <legionDataStore/dataTypes.h>
#include "legionStandardOM/views/entityView.h"
#include <legionStandardOM/sets/readEnvironmentProcessRepository.hpp>

class DtStateDataManager;
class DtVrfCallbackQueue;

namespace Legion
{
   class ViewManager;
}

namespace makVrf
{
   class DT_DLL_legionNetworkInterface DtRemoteObjectManager
   {
   public:
      DtRemoteObjectManager();

      virtual ~DtRemoteObjectManager();

      virtual void beginFrame();
      virtual void advanceFrame();

      virtual void init(DtStateDataManager*);

      DtStateDataManager* stateDataManager()
      {
         return myStateDataManager;
      }

      Legion::ViewManager* viewManager()
      {
         return myViewManager;
      }

      virtual void printReflectedObjectCounts() const;

      virtual void createRemoteObject(Legion::UInt64 id);

   protected:
      virtual void objectsAdded(const std::vector<LOM::ReadEntityRepository>&);
      virtual void objectsRemoved(const std::vector<LOM::ReadEntityRepository>&);

      virtual void environmentalObjectsAdded(const std::vector<LOM::ReadEnvironmentProcessRepository>&);
      virtual void environmentalObjectsRemoved(const std::vector<LOM::ReadEnvironmentProcessRepository>&);

   protected:
      virtual bool setupComponents(DtStateData*);

   protected:
      struct StateComponentAssociation
      {
         StateComponentAssociation(DtRemoteObjectManager* m) : myRemoteObjectManager(m) {};
         virtual ~StateComponentAssociation() {};
         virtual bool hasStateComponent(DtStateData* sd) const = 0;
         virtual void addStateComponent(DtStateData* sd) const = 0;
         virtual void addExistingStateComponents(DtStateData* sd) const = 0;

      protected:
         DtRemoteObjectManager* myRemoteObjectManager;
      };

      template <typename T_VRFStateComponent, typename T_LegionComponent>
      struct StateComponentAdder : public StateComponentAssociation
      {
         StateComponentAdder(DtRemoteObjectManager* m, bool onlyOne) : StateComponentAssociation(m), myOnlyOne(onlyOne)
         {
            myView = (typename Legion::SetView<T_LegionComponent>*)(m->viewManager()->createSetView<T_LegionComponent>());
            myView->addInstanceAddedCallback(typename Legion::SetView<T_LegionComponent>::InstanceCallback(this, &StateComponentAdder::handleLegionSetAdded));
            myView->addInstanceRemovedCallback(typename Legion::SetView<T_LegionComponent>::InstanceCallback(this, &StateComponentAdder::handleLegionSetRemoved));
         }

         virtual ~StateComponentAdder()
         {
            myView->removeInstanceAddedCallback(typename Legion::SetView<T_LegionComponent>::InstanceCallback(this, &StateComponentAdder::handleLegionSetAdded));
            myView->removeInstanceRemovedCallback(typename Legion::SetView<T_LegionComponent>::InstanceCallback(this, &StateComponentAdder::handleLegionSetRemoved));
            myRemoteObjectManager->viewManager()->destroyView(myView);
         }

         virtual void addExistingStateComponents(DtStateData* sd) const
         {
            addStateComponent(sd);
         }

         virtual void addStateComponent(DtStateData* sd) const
         {
            if (myOnlyOne && sd->hasStateComponent<T_VRFStateComponent>())
            {
               return;
            }

            if (sd->readStateInstance() && (T_LegionComponent::isType(sd->readStateInstance()->instanceHandle())))
            {
               sd->addStateComponent<T_VRFStateComponent>();
            }
            else
            {
               int componentCount = sd->componentCount<T_LegionComponent>();
               int i;

               for (i = 0; i < componentCount; i++)
               {
                  sd->addStateComponent<T_VRFStateComponent>();
               }
            }
         }

         virtual bool hasStateComponent(DtStateData* sd) const
         {
            return sd->findNextFrameLegionComponent<T_LegionComponent>().isValid();
         }

         virtual void handleLegionSetRemoved(const std::vector<T_LegionComponent>& objs)
         {
         }

         virtual void handleLegionSetAdded(const std::vector<T_LegionComponent>& objs)
         {
            if (myRemoteObjectManager->stateDataManager())
            {
               DtStateDataManager* sdm = myRemoteObjectManager->stateDataManager();

               int iLimit = objs.size();
               int i;

               for (i = 0; i < iLimit; ++i)
               {
                  DtStateData* sd = sdm->stateDataForLegionId(objs[i].globalId());

                  if (sd)
                  {
                     addStateComponent(sd);
                  }
               }
            }
         }

      protected:
         Legion::SetView<T_LegionComponent>* myView;
         bool myOnlyOne;
      };

   public:
      template <typename T_VRFComponent, typename T_LegionComponent> void
      registerLegionSetToStateComponent(bool onlyOne = false)
      {
         LegionSetToStateComponent::iterator iter = myLegionSetToStateComponent.find(T_LegionComponent::type());

         if (iter != myLegionSetToStateComponent.end())
         {
            delete iter->second;
         }

         myLegionSetToStateComponent[T_LegionComponent::type()] = new StateComponentAdder<T_VRFComponent, T_LegionComponent>(this, onlyOne);
      }

      virtual void setProcessRemoteObjectsInParallel(bool);
      bool processRemoteObjectsInParallel() const
      {
         return myProcessRemoteObjectsInParallel;
      }

      virtual void setNumCallbackThreads(unsigned);

      virtual bool rediscoverObjects();

   protected:
      DtStateDataManager* myStateDataManager;
      Legion::ViewManager* myViewManager;
      Legion::View* myEntityView;
      Legion::View* myEnvironmentalView;

      typedef std::map<Legion::UInt32, StateComponentAssociation*> LegionSetToStateComponent;
      LegionSetToStateComponent myLegionSetToStateComponent;

      std::vector<Legion::UInt64> myProcessNewObjects;
      bool myProcessRemoteObjectsInParallel;
      DtVrfCallbackQueue* myNetworkCallbackQueue;
   };
}