DtDynamicFidManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvUtil/DtDynamicTerrainChange.h>
#include <vrvUtil/DtDynamicTerrainSphere.h>

#include <tbb/mutex.h>
#include <tbb/spin_mutex.h>

#include <osg/BoundingBox>

#include <set>
#include <deque>
#include <vector>
#include <unordered_map>

namespace osgEarth
{
   class MapNode;
}

namespace makVrv
{

   typedef long long DtFid;
   typedef unsigned long DtDynamicFidChangeId;

   // Holds info about a single FID that has been dynamically changed.
   // This includes the alternative model put in place (if any)
   class DT_DLL_VRVOSG DtDynamicFidEntry
   {
   public:
      DtDynamicFidEntry(DtFid fid);
      virtual ~DtDynamicFidEntry() {};

      virtual void inrementRefCount();
      virtual void decrementRefCount();
      virtual unsigned int refCount() const;
      virtual DtFid fid() const { return myFid; };
      virtual void setBoundingBox(const osg::BoundingBox& bb) { myBoundingBox = bb; };
      virtual osg::BoundingBox boundingBox() const { return myBoundingBox; }
      // Returns true if the reference count was previously (since last clearHistory() call) 0 and is now greater than 0.
      virtual bool newlyReferenced() const;
      // Returns true if the reference count was previously (since last clearHistory() call) non-zero and is now 0.
      virtual bool newlyUnreferenced() const;
      // Clears history for newlyReference() and newlyUnreferenced().
      virtual void clearHistory();

   protected:
      DtFid myFid;
      osg::BoundingBoxd myBoundingBox;
      // The number of DtDynamicFidChangeEntry instances that point to this entry.
      unsigned int myRefCount;
      unsigned int myPrefRefCount;

   };

   // Holds info on a single change request to dynamic FIDs
   // This change request may affect 0 or more FIDs
   // This entry holds pointers to the FIDs that have been altered
   // and preserves the change info that that addition FIDs can be altered
   // as needed as terrain pages in.
   class DT_DLL_VRVOSG DtDynamicFidChangeEntry
   {
   public:
      DtDynamicFidChangeEntry(std::shared_ptr< DtDynamicTerrainChange > changeCommand,
         DtDynamicFidChangeId changeId);
      ~DtDynamicFidChangeEntry();
      // Adds the fid entry to the list, and increments the ref count of the fid entry.
      void addChangedFid(DtDynamicFidEntry* fidEntry);
      // Removes the fid entry and decrements the ref count of the fid entry.
      void removeChangedFid(DtDynamicFidEntry* fidEntry);
      // Clears the fid entry list and decrements ref counter of fid entries.
      void removeAllFidEntries();
      std::shared_ptr< DtDynamicTerrainChange > change();
      std::set<DtFid> currentFids() const;
      DtDynamicFidChangeId changeId() const;

   protected:
      // List of FIDs currently altered by this change
      std::vector<DtDynamicFidEntry*> myAlteredFids;
      //std::shared_ptr<DtDynamicTerrainRequestHandle::RequestHandleImpl> myChangeHandle;
      std::shared_ptr< makVrv::DtDynamicTerrainChange > myChangeCommand;
      DtDynamicFidChangeId myChangeId;

   };

   typedef std::shared_ptr<DtDynamicFidChangeEntry> DtDynamicFidChangeEntryPtr;

   class DtDynamicFidManager;

   // Manages altering FIDs in the terrain based on a list of requests passed
   // to this manager.
   // This manager keeps the current requests and applies changes to terrain as it pages in,
   // as well as applying to terrain already paged in.
   // Changes can be removed, and will result in reverting FIDs to their original state.
   // If multiple changes affect the same FID, that FID will only be reverted when all 
   // related changes have been removed.
   // 
   // When changes are added/removed, the internal state of the manager is updated, but 
   // changes are not pushed to the terrain system until updateTerrain() is called.
   // 
   // This is an abstract base class to manage the data, but does not interface with the 
   // terrain directly, so that it can be used in both VRV and VRF Sim.
   // Subclasses must implement destroyFid() and resotreFid() in order to apply the changes
   // to their terrain.
   // Subclasses also must implement their own add and remove functions, which should call
   // addChangeRequestInternal() and removeChangeInternal().  This is so that subclasses
   // can manage how they track changes in their own way.
   class DT_DLL_VRVOSG DtDynamicFidManager
   {
   public:
      DtDynamicFidManager();
      virtual ~DtDynamicFidManager();

      // Updates the terrain with any changes that have been added/removed since the last updateTerrain() call.
      // This call results in calls to destroyFid() and restoreFid().
      virtual void updateTerrain();
      
      // Intentional no-op derived classes override to call reapplyChanges( tbb::concurrent_vector& )
      virtual void reapplyChangesIfRequired();
      virtual void reapplyChanges( std::deque<DtDynamicTerrainSphere>& queue );
      // 
      // Reapply all changes that were previously added.
      // This calls updateTerrain() when complete.
      virtual void reapplyChanges();

      // \return True if the specified FID should currently be hidden, based on changes in this FID manager.
      virtual bool isFidHidden(const DtFid fid) const;

   protected:
      // Called whenever a fid entry changes to the destroyed state.
      // Subclasses should override this call to alter their terrain representation.
      virtual void destroyFids(const std::vector<DtDynamicFidEntry*>& fidEntries) = 0;
      // Called whenever a fid entry is restored from the destroyed state to the normal state.
      // Subclasses should override this call to alter their terrain representation.
      virtual void resotreFids(const std::vector<DtDynamicFidEntry*>& fidEntries) = 0;

      // Override to provide the MapNode used by this class.
      virtual osgEarth::MapNode* mapNode() = 0;

      // Creates and returns a DtDynamicFidEntry.  Override to create a subclass to hold implementation specific data.
      virtual DtDynamicFidEntry* createDynamicFidEntry(DtFid fid);

      // This function is called from updateTerrain() with a list of all entries that have been 
      // modified since the last call to updateTerrain().  Override this function to provide notification
      // to other parts of the system about terrain changes.
      // Default implementation does nothing.
      virtual void notifyModifications(const std::vector<DtDynamicFidEntry*>& modifiedEntries);

      // Internal logic for adding a change request that returns the new entry (if created).
      // Here to allow subclasses to customize the addChangeRequest logic to return handles/ids of their choice.
      virtual std::shared_ptr<DtDynamicFidChangeEntry> addChangeRequestInternal(const makVrv::DtDynamicTerrainChange& changeCommand);

      // This call should not normally be made by the client code, and is here to be called from DtDynamicFidTerrainRequestHandleImpl::removeChange().
      virtual void removeChangeInternal(std::shared_ptr<DtDynamicFidChangeEntry> changeEntry);

      // Finds the currently loaded FIDs that match this change, and if they are not already tracked by the change entry,
      // add them to the change and call destroyFid() as needed for any new ones.
      // This call is appropriate for when a change is new and also when new terrain has paged in and new FIDs might be available.
      // This call does not make changes to the DtCollisionWorld.  It alters the internal state of which FIDs are hidden.
      // The next call to updateTerrain() after this call is made will apply changes to the collision world.
      virtual void refreshChange(DtDynamicFidChangeEntryPtr changeEntry);

   protected:
      std::unordered_map<DtDynamicFidChangeId, DtDynamicFidChangeEntryPtr > myChanges;
      std::unordered_map<DtFid, DtDynamicFidEntry*> myAlteredFids;
      DtDynamicFidChangeId myNextChangeId;
      mutable tbb::spin_mutex myMutex;
   };
};