vortexDynamicTerrainHandler.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2024 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file    vortexDynamicTerrainHandler.h
//! \brief   Provides management of dynamic terrain events within the Vortex physics engine
//! \ingroup vreVrfVortex
 
#pragma once
 
#include <vreVrfVortex/export.h>
 
#include <terrainInterface/terrainInterface.h>
 
#include <tbb/concurrent_unordered_map.h>
 
// Forward declares
class DtTerrainImplementation;
class DtLocalObject;
class DtDynamicTerrainQueryHandle;
 
namespace makVrv
{
class DtDynamicTerrainFeature;
class DtDynamicTerrainChange;
class DtDynamicTerrainChanges;
} // namespace makVrv
 
namespace Vx
{
class VxTriangleMeshBVTree;
}
 
namespace VxTerrain
{
class VxTerrainRequest;
}
 
namespace makVre
{
class DtVortexPhysicalWorld;
class DtVortexPagedTerrainProducer;
 
//! \brief Manages dynamic terrain events and updates in the Vortex physics engine
//!
//! This class is responsible for handling dynamic terrain modifications in VR-Forces
//! and translating them to the Vortex physics engine. It processes terrain change
//! notifications, identifies affected terrain cells, and schedules regeneration
//! of collision geometries to reflect the terrain changes.
class VREVRFVORTEX_DLL DtVortexDynamicTerrainHandler
{
public:
   //! \brief Map type for tracking dynamic terrain modification requests
   //!
   //! Maps terrain cell source IDs to new triangle meshes that need to be applied.
   using DynamicTerrainRequestMap = tbb::concurrent_unordered_map<int, Vx::VxTriangleMeshBVTree*>;
 
public:
   //! \brief Constructor
   //!
   //! Initializes the dynamic terrain handler with a reference to the Vortex physical world.
   //! Only the physical world should create this handler.
   //!
   //! \param physicalWorld Pointer to the Vortex physical world that owns this handler
   explicit DtVortexDynamicTerrainHandler(DtVortexPhysicalWorld* physicalWorld);
 
   //! \brief Destructor
   virtual ~DtVortexDynamicTerrainHandler();
 
   //! \brief Registers this handler with the terrain system
   //!
   //! Connects to the terrain change notification callback in the terrain interface
   //! to receive notifications when terrain is modified.
   void registerDynamicTerrainHandler();
 
   //! \brief Unregisters this handler from the terrain system
   //!
   //! Disconnects from the terrain change notification callback, stopping
   //! the processing of terrain modifications.
   void unregisterDynamicTerrainHandler();
 
   //! \brief Swaps the internal dynamic terrain request map with the provided map
   //!
   //! Used to safely extract pending terrain modification requests for processing.
   //! The provided map is typically empty before the call and contains all pending
   //! requests after the call.
   //!
   //! \param reqMap Map to swap with the internal request map
   virtual void swapDynamicTerrainRequests(DynamicTerrainRequestMap& reqMap);
 
   //! \brief Checks if two bounding boxes intersect
   //!
   //! Determines if two Vortex bounding boxes overlap in 3D space.
   //! Used to identify which terrain cells are affected by a terrain modification.
   //!
   //! \param firstBB First bounding box to check
   //! \param secondBB Second bounding box to check
   //! \return True if the boxes intersect, false otherwise
   virtual bool doBoxesIntersect(const VxMath::BoundingBox& firstBB, const VxMath::BoundingBox& secondBB) const;
 
   //! \brief Checks if new terrain modification requests are available
   //!
   //! \return True if there are pending terrain modification requests, false otherwise
   virtual bool newRequestsAvailable() const;
 
   //! \brief Resets all pending terrain modification requests
   //!
   //! Clears all pending terrain modification requests and performs cleanup.
   //! This is typically called when the scenario is reset or a new terrain is loaded.
   virtual void reset();
 
protected:
   //! \brief Static callback function for terrain change notifications
   //!
   //! This static function is registered with the terrain interface and
   //! forwards terrain change notifications to the appropriate instance.
   //!
   //! \param terrainChangeInfo Information about the terrain change
   //! \param usr Pointer to the DtVortexDynamicTerrainHandler instance
   static void terrainChangeNotification(const DtTerrainChangeNotificationInfo& terrainChangeInfo, void* usr);
 
   //! \brief Processes a terrain change notification
   //!
   //! Identifies terrain cells affected by the terrain change and creates
   //! requests for regenerating their collision geometries. The affected cells
   //! are determined by checking for intersection between the terrain change
   //! bounding box and the cell bounding boxes.
   //!
   //! \param terrainChangeInfo Information about the terrain change
   virtual void processTerrainChangeNotification(const DtTerrainChangeNotificationInfo& terrainChangeInfo);
 
protected:
   DtVortexPhysicalWorld* myPhysicalWorld;            //!< Pointer to the Vortex physical world
   DynamicTerrainRequestMap myDynamicTerrainRequests; //!< Map of pending terrain modification requests
};
} // namespace makVre