vortexPagedTerrainProducer.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2024 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file    vortexPagedTerrainProducer.h
//! \brief   Producer that manages terrain insertion into the Vortex physics universe
//! \ingroup vreVrfVortex
 
#pragma once
 
#include <vreVrfVortex/export.h>
 
#include <VxTerrain/VxPagedTerrainProducer.h>
 
#include <tbb/spin_mutex.h>
 
namespace Vx
{
class VxCollisionGeometry;
}
 
namespace makVre
{
//! \brief Producer that manages terrain in the Vortex physics universe
//!
//! This class manages the terrain being inserted into the Vortex universe,
//! maintaining a collection of paged cells with collision geometries.
//! It also handles dynamic terrain within Vortex.
class VREVRFVORTEX_DLL DtVortexPagedTerrainProducer : public VxTerrain::VxPagedTerrainProducer
{
public:
   //! \brief Structure for managing paged terrain cells
   //!
   //! Represents a single cell of terrain in the paged terrain system,
   //! with its request information and collision geometry.
   struct PagedCell
   {
      //! \brief Constructor
      PagedCell();
 
      //! \brief Destructor
      ~PagedCell();
 
      int requestId;                              //!< Request ID of this paged cell
      VxMath::BoundingBox requestBoundingBox;     //!< Bounding box of this request
      Vx::VxCollisionGeometry* collisionGeometry; //!< Collision geometry of the paged cell
   };
 
   //! \brief Map type for storing paged cells indexed by source ID
   using PagedCells = std::unordered_map<int, PagedCell*>;
 
public:
   //! \brief Constructor
   //!
   //! Initializes a new terrain producer with default settings.
   DtVortexPagedTerrainProducer();
 
   //! \brief Destructor
   //!
   //! Cleans up terrain cells and resources.
   virtual ~DtVortexPagedTerrainProducer() override;
 
   //! \brief Performs pre-step operations
   //!
   //! Gets collision geometries of parts, maps terrain requests, and sets request
   //! priorities before stepping. Also manages the PagedCells being tracked.
   virtual void preStep() override;
 
   //! \brief Inserts terrain with new collision geometry
   //!
   //! Adds the specified parts and collision geometries to the area of a given request
   //! with the received source ID. Use when the terrain element is not already present.
   //! Also inserts this into the myPagedCells map.
   //!
   //! \param sourceId Source ID to link this collision geometry to
   //! \param requestId Request ID to link this collision geometry to
   //! \param requestBounds Request bounds of this terrain request
   //! \param cg Collision geometry to insert
   void insertTerrain(int sourceId, int requestId, VxMath::BoundingBox requestBounds, Vx::VxCollisionGeometry* cg);
 
   //! \brief Inserts terrain with existing source ID
   //!
   //! Calls default insertTerrain where a request ID shares the same source ID as another request.
   //!
   //! \param sourceId Source ID to link this collision geometry to
   //! \param requestId Request ID to link this collision geometry to
   void insertTerrain(int sourceId, int requestId);
 
   //! \brief Gets the paged cell for a source ID
   //!
   //! \param sourceId The source ID to look up
   //! \return Pointer to the paged cell, or nullptr if not found
   PagedCell* getPagedCellForSourceID(int sourceId);
 
   //! \brief Gets all paged cells
   //!
   //! \return Map of all paged cells indexed by source ID
   PagedCells getPagedCells();
 
   //! \brief Gets all collision geometries
   //!
   //! \return Vector of all collision geometries in the terrain
   virtual std::vector<Vx::VxCollisionGeometry*> getAllCollisionGeometries();
 
   //! \brief Checks if terrain is available below coordinates
   //!
   //! \param inputCords Position to check for terrain
   //! \return True if terrain exists below the coordinates, false otherwise
   bool isTerrainAvailable(const VxMath::Vector3& inputCords);
 
   //! \brief Sets the terrain cell size
   //!
   //! \param cellSize The new cell size in meters
   void setTerrainCellSize(double cellSize);
 
   //! \brief Gets the terrain cell size
   //!
   //! \return The current cell size in meters
   double getTerrainCellSize() const;
 
protected:
   //! \brief Initializes the paged terrain producer
   //!
   //! Internal method called during initialization.
   virtual void _initialize() override;
 
protected:
   double myPagedTerrainCellSize; //!< Size of terrain cells in meters
   PagedCells myPagedCells;       //!< Map of all paged cells by source ID
   tbb::spin_mutex myInsertMutex; //!< Mutex for thread-safe insertion
};
} // namespace makVre