DtEntityProcessor.h

Go to the documentation of this file.

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


#pragma once

#include <vrvLegion/vrvLegion.h>
#include <vrvLegion/diGuyFacade.h>
#include <legionStandardOM/sets/readEntityRepository.hpp>

#include <vrvUtil/DtVirtualBaseClass.h>

#include "legionDataStore/dataTypes.h"

#include <boost/signals2.hpp>

namespace LOM
{
   class EntityView;
}

class DtEntityType;

namespace makVrv
{
   class DtBaseConnection;
   class DtLegionConnection;
   class DtDiGuyFacade;
   class DtCoordinateSystem;

   class AttributeIndexCache
   {
   public:
      Legion::UInt32 lastReceivedLocAttrIndex;
      Legion::UInt32 lastReceivedVelAttrIndex;
      Legion::UInt32 lastReceivedAccAttrIndex;
      Legion::UInt32 lastReceivedOriAttrIndex;
      Legion::UInt32 lastReceivedRotVelAttrIndex;
      Legion::UInt32 lastReceivedTimeAttrIndex;
   };

   class VRV_LEGION_DLL DtEntityProcessor : public DtVirtualBaseClass
   {
   public:
      DtEntityProcessor(DtLegionConnection& conn);

      static void registerInstance(DtBaseConnection& conn, DtEntityProcessor* instance);

      static DtEntityProcessor* findInstance(DtBaseConnection& conn);

      virtual ~DtEntityProcessor();

      virtual void tick();

      virtual int maxDrawAbleEntities();
      virtual void setMaxDrawableEntities(int val);

      virtual int maxEntityCache();
      virtual void setMaxEntityCache(int val);

      virtual float fov();
      virtual void setFov(float val);

      virtual float realizeRange();
      virtual void setRealizeRange(float val);

      virtual int maxCreatePerFrame();
      virtual void setMaxCreatePerFrame(int val);
      
      virtual int maxRemovePerFrame();
      virtual void setMaxRemovePerFrame(int val);
         
      virtual void setRegisterEntity(bool val);
      virtual bool registerEntity();

      virtual void setUseNetworkAppearances(bool val);

      void setCoordinateSystem(makVrv::DtCoordinateSystem* cs) { myCoordinateSystem = cs; };
      std::string modelDefinitionFor(const DtEntityType& objectType, bool& isHuman) const;

      virtual void createDiGuyFacade(Legion::UInt64 id, const std::string& def);
      virtual void createEntityFacade(Legion::UInt64 id, const std::string& def);

      void precache();

      boost::signals2::signal<void (makVrv::DtUniqueID, Legion::UInt64)> signal_elementCreated;
      boost::signals2::signal<void (makVrv::DtUniqueID, Legion::UInt64)> signal_elementDestroyed;
      boost::signals2::signal<void ()> signal_allElementsDestroyed;

   protected:
      DtLegionConnection& myConnection;

      struct EntityVis;
      void entitiesInView();
      bool createEntity(Legion::UInt64);
      void updateEntity(EntityVis& ent);
      void setKinematicState(EntityVis& vis, LOM::ReadEntityRepository& esr);
      void setVisualState(EntityVis& vis, LOM::ReadEntityRepository& esr);
      void removeEntities();
      void sortEntitesInView();

      //for sorting the entities by distance from observer
      void quicksort(int low, int high);
      int partition(int low, int high);
      inline void swapEntities(int a, int b);
      void cacheAttributeIndices();

      int myFrameNumber;
      LOM::EntityView* myEntityView;
      float myRealizeRange;
      bool myUseNetworkAppearances;
      double myTimeoutPeriod;

      struct EntityVis
      {
         Legion::UInt64 entityId;
         DtDiGuyFacade* facade;
         double frameUpdated;

         EntityVis() :entityId(0), facade(0), frameUpdated(0) {}
         EntityVis(Legion::UInt64 e, DtDiGuyFacade* f, int u) : entityId(e), facade(f), frameUpdated(u) {}
      };

      typedef std::map<Legion::UInt64, EntityVis> VisualizerMap;
      VisualizerMap myVisualizers;
      std::vector<EntityVis> myFreeDiGuys;
      std::vector<Legion::InstanceHandle> myVisibleEntities;

      int myMaxDrawableEntities;
      int myMaxEntityCache;
      float myFov;
      int myMaxCreatePerFrame;
      int myMaxRemovePerFrame;
      bool myRegisterEntities;

      AttributeIndexCache myAttributeIndexCache;
      bool myAreAttributeIndicesCached;

      makVrv::DtCoordinateSystem* myCoordinateSystem;
   };
}