DtSceneObjectUpdater.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/DtSceneObject.h>
#include <vrvCore/DtTickable.h>

#include <vrvUtil/signalslib.h>

#include <map>
#include <unordered_map>

namespace makVrv
{
   class DtDe;
   enum class DtModelSetId;

   class DT_DLL_VRVCORE DtSceneObjectUpdater : public DtTickable
   {
   public:

      DtSceneObjectUpdater( DtDe& de, DtUniqueID id );

      virtual ~DtSceneObjectUpdater();

      virtual void setNextUpdater( DtSceneObjectUpdater* nextUpdater );

      virtual void setPrevUpdater( DtSceneObjectUpdater* prevUpdater );

      virtual bool needsUpdate( DtTime tNow );

      virtual void update( DtTime tNow );

      virtual void updateAdaptiveTickrate(const DtVector& lastPos, const DtTime& deltaTime);
      
      virtual void setVertexToUpdate( unsigned int vertex );

      virtual void setInputPosition( const DtVector& position );

      virtual void setInputOrientation( const DtTaitBryan& orientation );

      virtual void setOutputPosition( const DtVector& position );
      
      virtual DtVector outputPosition() const;

      virtual void setOutputOrientation( const DtTaitBryan& orientation );
      
      virtual DtTaitBryan outputOrientation() const;

      virtual void setOutputPositionAndOrientation(const DtVector& position, const DtTaitBryan& orientation);

      virtual DtTime lastUpdateTime() const;

      virtual void setSceneObject(DtSceneObject* sceneObject, bool addToTickableMgrIfHead);

      virtual void setSceneObject(DtSceneObject* sceneObject);

      virtual void setAdaptiveTickLodEnabled(bool enabled);
      virtual bool adaptiveTickLodEnabled() const override;

      virtual void setLodScaleSpeedFactor(float factor);
      virtual float lodScaleSpeedFactor() const;

      virtual void setLodRadiusStart(float ratius);
      virtual float lodRadiusStart() const;

      virtual void setLodRadiusEnd(float ratius);
      virtual float lodRadiusEnd() const;

      virtual void setNearLodUpdateRate(int nearRate);
      virtual int nearLodUpdateRate() const;

      virtual void setFarLodUpdateRate(int maxRate);
      virtual int farLodUpdateRate() const;


      inline DtSceneObject* findActiveSceneObject()
      {
         if( mySceneObjectMap.size() )
         {
            return mySceneObjectMap.begin()->second;
         }
         return nullptr;
      }

      inline DtSceneObject* const findActiveSceneObject() const
      {
         if( mySceneObjectMap.size() )
         {
            return mySceneObjectMap.begin()->second;
         }
         return nullptr;
      }

      inline DtSceneObject* findSceneObjectForModelSet( DtModelSetId modelSet )
      {
         auto keyVal = mySceneObjectMap.find( modelSet );
         if( keyVal != mySceneObjectMap.end() )
         {
            return keyVal->second;
         }
         return nullptr;
      }

      inline DtSceneObject* const findSceneObjectForModelSet( DtModelSetId modelSet ) const
      {
         auto keyVal = mySceneObjectMap.find( modelSet );
         if( keyVal != mySceneObjectMap.end() )
         {
            return keyVal->second;
         }
         return nullptr;
      }

      inline DtUniqueID uniqueId() const
      {
         return myUniqueId;
      }

      inline DtSceneObjectUpdater* findNextUpdater() const
      {
         return myNextUpdater;
      }

      inline DtSceneObjectUpdater* findPrevUpdater() const
      {
         return myPrevUpdater;
      }

      virtual bool isChainThreadSafe(DtSceneObjectUpdater* firstUpdater);

      virtual DtSceneObjectUpdater* chainHead();

      virtual void setIsThreadSafe(bool safe);
 
      boost::signalslib::signal< void ( const DtUniqueID& ) > signal_updaterToBeDeleted;

      virtual void addSceneObjectToUpdate( DtModelSetId modelSet, DtSceneObject* sceneObject, bool addToTickableMgrIfHead=true );
      virtual void removeSceneObjectToUpdate( DtModelSetId modelSet, DtSceneObject* sceneObject );

      virtual void addSceneObjectToUpdateAtChainEnd( DtModelSetId modelSet, DtSceneObject* sceneObject, bool addToTickableMgrIfHead = true );
      virtual void removeSceneObjectToUpdateAtChainEnd( DtModelSetId modelSet, DtSceneObject* sceneObject );

      virtual void setTickableEnabled( bool enabled ) override;
   protected:
      virtual void slot_sceneObjectToBeDeleted( const DtUniqueID& id );

      virtual void removeThreadSafeChainFromManager(DtSceneObjectUpdater* head);

      virtual void removeUnThreadSafeChainFromManager(DtSceneObjectUpdater* head);

      virtual void addThreadSafeChainToManager(DtSceneObjectUpdater* head);

      virtual void addUnThreadSafeChainToManager(DtSceneObjectUpdater* head);

      virtual void placeChainOnCorrectTickableList(DtSceneObjectUpdater* head);
   protected:

      DtDe& myDe;

      DtUniqueID myUniqueId;

      //DtSceneObject* mySceneObject;

      DtModelSetId myModelSet;


      //  When the class is destructed, the scene object may or may not 
      // exist.  Using a separate connection variable makes it possible to
      // 'disconnect' even if the scene object has been deleted.
      boost::signalslib::connection mySceneObjectConnection;

      DtSceneObjectUpdater* myNextUpdater;

      DtSceneObjectUpdater* myPrevUpdater;

      unsigned int myVertexToUpdate;

      DtVector myLastPositionForAdaptiveTickRate;

      DtVector myInputPosition;

      DtTaitBryan myInputOrientation;
      
      DtVector myLastOutputPosition;

      DtTaitBryan myLastOutputOrientation;

      bool myPositionDataOutputted;

      bool myOrientationDataOutputted;

      using ModelSetToSceneObjectMap = std::map<DtModelSetId, DtSceneObject*>;

      ModelSetToSceneObjectMap mySceneObjectMap;

      using SceneObjectConnectionsMap = std::unordered_map<DtUniqueID,boost::signalslib::connection>;

      SceneObjectConnectionsMap mySceneObjectConnectionsMap;

      struct AdaptiveTickRateLODParams
      {
         AdaptiveTickRateLODParams();
         bool myEnabled;

         float myScaleSpeedFactor; // 20.0f

         float myNearUpdateRadius; // 1000.0f

         float myFarUpdateRadius; // 10000.0f

         int myFarUpdateRate; // 30

         int myNearUpdateRate; // 6

      };
      AdaptiveTickRateLODParams myAdaptiveTickRateLODParams;
   };
}