vortexCollisionProxyGenerator.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2024 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file    vortexCollisionProxyGenerator.h
//! \brief   Manages collisions between Vortex-simulated vehicles and non-Vortex vehicles
//! \ingroup vreVrfVortex
 
#pragma once
 
#include <vreVrfVortex/export.h>
 
#include <vreUtil/coordConverter.h>
 
#include <VxMath/VxMath.h>
 
#include <matrix/vlVector.h>
 
#include <vrfobjcore/simObjectReference.h>
#include <vrfobjcore/compositePredicate.h>
#include <vrfobjcore/simObject.h>
 
#include <tbb/spin_mutex.h>
 
class DtCgf;
 
namespace Vx
{
class VxPart;
}
 
namespace makVre
{
// fwd declarations
class DtVortexPhysicalWorld;
 
//! \brief Manages collision detection and handling between Vortex physics objects and non-Vortex simulated objects
//!
//! This class tracks VR-Forces (non-Vortex) vehicles using proxy representations and creates
//! corresponding collision geometries in the Vortex physics universe. It maintains lists of
//! nearby vehicles for each Vortex-simulated vehicle, updates their positions, and processes
//! collision events between Vortex and non-Vortex objects.
class VREVRFVORTEX_DLL DtVortexCollisionProxyGenerator
{
public:
   //! \brief Constructor
   //!
   //! Initializes the collision proxy generator with the provided physical world and CGF instance.
   //! Sets up default values for proxy count, search radius, and vehicle mass.
   //!
   //! \param world Pointer to the Vortex physical world
   //! \param cgf Pointer to the CGF instance for callback registration
   DtVortexCollisionProxyGenerator(DtVortexPhysicalWorld* world, DtCgf* cgf);
 
   //! \brief Destructor
   //!
   //! Cleans up all proxy vehicles from the Vortex universe and clears data structures.
   virtual ~DtVortexCollisionProxyGenerator();
 
   //! \brief Default constructor, copy constructor, and copy assignment operator not allowed
   DtVortexCollisionProxyGenerator() = delete;
   DtVortexCollisionProxyGenerator(const DtVortexCollisionProxyGenerator&) = delete;
   DtVortexCollisionProxyGenerator& operator=(const DtVortexCollisionProxyGenerator&) = delete;
 
   //! \brief Updates lists of nearest vehicles and checks for collisions
   //!
   //! Called each simulation frame to update the positions of proxy vehicles
   //! in the Vortex universe and process any collisions that occurred.
   virtual void update();
 
   //! \brief Adds a Vortex vehicle to the tracked vehicles list
   //!
   //! Registers a new Vortex-simulated vehicle by its UUID for collision handling.
   //!
   //! \param uuid The UUID of the Vortex vehicle to track
   virtual void addVortexVehicle(const DtUUID& uuid);
 
   //! \brief Removes a Vortex vehicle from the tracked vehicles list
   //!
   //! Unregisters a Vortex-simulated vehicle and removes its associated proxy vehicles.
   //!
   //! \param uuid The UUID of the Vortex vehicle to stop tracking
   virtual void removeVortexVehicle(const DtUUID& uuid);
 
   //! \brief Sets the entity types that Vortex vehicles will collide with
   //!
   //! Updates the filter for determining which object types should be considered
   //! for collision detection with Vortex-simulated vehicles.
   //!
   //! \param entityTypes Vector of entity types to consider for collision detection
   virtual void setTypesToCollideWith(std::vector<DtEntityType> entityTypes);
 
   //! \brief Callback executed when a scenario is rewound
   //!
   //! Clears all vehicle lists and mappings to prevent accessing invalid data
   //! after a scenario rewind operation.
   void rewindCallback();
 
   //! \brief Renders ImGui debug interface for collision proxy visualization
   //!
   //! Provides a graphical user interface for debugging and monitoring the collision
   //! proxy generator's state, including tracked vehicles and active proxies.
   //! Override this method to customize debug visualization.
   virtual void renderImgui();
 
   //! \brief Clears all internal data structures
   //!
   //! Removes all tracked Vortex vehicles, proxy vehicles from the universe,
   //! and clears all internal mappings between UUIDs and Vortex parts.
   //! This method is called during destruction and scenario rewind to ensure
   //! clean state and prevent accessing invalidated data.
   //!
   //! \note This method removes proxy vehicles from the Vortex universe before
   //!       clearing the data structures to ensure proper cleanup.
   virtual void clearDataStructures();
 
protected:
   //! \brief Checks if a vehicle is player controlled
   //!
   //! Determines if a given vehicle is currently being controlled by a player
   //! as a driver.
   //!
   //! \param vehicle The vehicle to check
   //! \return True if the vehicle is player controlled, false otherwise
   virtual bool isPlayerControlled(const DtSimObject& vehicle) const;
 
protected:
   //! \brief Structure representing a non-Vortex vehicle for collision detection
   //!
   //! This structure holds the necessary information to represent a VR-Forces simulated
   //! ground vehicle in the Vortex physics universe for collision detection.
   struct DtVrfProxyVehicle
   {
      DtSimObjectReference vrfObject; //!< Reference to the VR-Forces simulation object
      DtUUID uuid;                    //!< The VRF UUID of this entity (cached for when vrfObject no longer exists)
      DtVector locationInWorld;       //!< Location of this vehicle in local Dt coordinates (x-east, y-north, z-up)
      double heading;                 //!< Heading of this vehicle in radians
      double distance;                //!< Distance between this vehicle and its associated Vortex vehicle
 
      //! \brief Comparison operator for sorting by distance
      //!
      //! \param other The other proxy vehicle to compare against
      //! \return True if this vehicle is closer than the other vehicle
      bool operator<(const DtVrfProxyVehicle& other) const { return distance < other.distance; }
   };
 
   //! \brief Number of nearby non-Vortex vehicles to track for each Vortex vehicle
   int myNumProxyVehicles;
 
   //! \brief Maximum distance in meters to search for nearby vehicles
   int mySearchRadius;
 
   //! \brief Default mass in kg for non-Vortex vehicles
   //!
   //! This value is used when creating collision proxies in the Vortex universe.
   //! It's deliberately set high to make the vehicles behave as heavy objects.
   double myDefaultVrfVehicleMass;
 
   //! \brief Adds a proxy vehicle to the Vortex physics universe
   //!
   //! Creates a Vortex VxPart representation of a VR-Forces vehicle for collision detection.
   //!
   //! \param vreProxyVehicle The proxy vehicle to add to the Vortex universe
   void addProxyVehicleToVortexUniverse(const DtVrfProxyVehicle& vreProxyVehicle);
 
   //! \brief Updates the position of a proxy vehicle in the Vortex universe
   //!
   //! Adjusts the position and orientation of a proxy vehicle's Vortex representation
   //! to match its current state in VR-Forces.
   //!
   //! \param proxyVehicleUUID The UUID of the proxy vehicle to update
   //! \param vortexVehicleUUID The UUID of the corresponding Vortex vehicle
   void updateProxyVehicleInVortexUniverse(const DtUUID& proxyVehicleUUID, const DtUUID& vortexVehicleUUID);
 
   //! \brief Removes a proxy vehicle from the Vortex universe
   //!
   //! Deletes a proxy vehicle's Vortex representation and updates the tracking maps.
   //!
   //! \param VxProxyVehicle Pointer to the Vortex part representing the proxy vehicle
   void removeProxyVehicleFromVortexUniverse(Vx::VxPart* VxProxyVehicle);
 
   //! \brief Updates the list of closest vehicles for a given Vortex vehicle
   //!
   //! Finds the nearest non-Vortex vehicles to a specified Vortex vehicle
   //! and creates or updates proxy representations for them.
   //!
   //! \param uuid The UUID of the Vortex vehicle to update proxies for
   virtual void updateClosestVehicleList(const DtUUID& uuid);
 
   //! \brief Removes proxy vehicles that are no longer within the search radius
   //!
   //! Cleans up proxies that have moved away from the specified Vortex vehicle.
   //!
   //! \param uuid The UUID of the Vortex vehicle to check proxies against
   virtual void clearDistantVehicles(const DtUUID& uuid);
 
   //! \brief Collects nearby simulation objects around a search center
   //!
   //! Finds all simulated objects of appropriate types within the search radius
   //! of the specified position.
   //!
   //! \param searchCenter The center point for the search
   //! \param results Vector to be filled with pointers to nearby objects
   virtual void collectNearbySimObjects(const DtVector& searchCenter, std::vector<const DtSimObject*>& results);
 
   //! \brief Handles a collision between two Vortex parts
   //!
   //! Processes a collision detected by the Vortex physics engine, generates
   //! appropriate VR-Forces collision events, and removes the proxy to prevent
   //! persistent collisions.
   //!
   //! \param part0 First Vortex part involved in the collision
   //! \param part1 Second Vortex part involved in the collision
   virtual void handleVortexCollision(Vx::VxPart* part0, Vx::VxPart* part1);
 
   //! \brief Converts from VR-Forces coordinates to Vortex coordinates
   //!
   //! Translates position vectors between coordinate systems based on
   //! whether the terrain is geocentric or local/flat.
   //!
   //! \param vec Position vector in VR-Forces coordinates
   //! \return Equivalent position vector in Vortex coordinates
   virtual VxMath::Vector3 toVxCoords(const DtVector& vec);
 
   //! \brief Timestamp of the last sent collision interaction
   //!
   //! Used to limit the frequency of collision events for performance reasons.
   DtTime myLastCollisionInteractionTime;
 
   //! \brief Flag indicating if the terrain uses geocentric coordinates
   bool myTerrainIsGeocentric;
 
   //! \brief Flag indicating if the coordinate converter has been set
   bool myCoordConverterIsSet;
 
   //! \brief Coordinate converter for geocentric/local transformations
   DtCoordinateConvert* myCoordConverter;
 
   //! \brief List of UUIDs for all Vortex vehicles being tracked
   std::vector<DtUUID> myVortexVehicles;
 
   //! \brief Map from Vortex vehicle UUIDs to lists of nearby proxy vehicles
   std::map<DtUUID, std::vector<DtVrfProxyVehicle>> myClosestVehicleMap;
 
   //! \brief Pointer to the Vortex physical world
   DtVortexPhysicalWorld* myVortexPhysicalWorld;
 
   //! \brief List of all proxy vehicle parts in the Vortex universe
   //!
   //! Cached for efficient cleanup during destruction.
   std::vector<Vx::VxPart*> myProxyVehiclesInUniverse;
 
   //! \brief Mapping from Vortex parts to VR-Forces UUIDs
   std::map<Vx::VxPart*, DtUUID> myVxPartToUUIDMap;
 
   //! \brief Mapping from VR-Forces UUIDs to Vortex parts
   std::map<DtUUID, Vx::VxPart*> myUUIDToVxPartMap;
 
   //! \brief List of entity types that Vortex vehicles will collide with
   std::vector<DtEntityType> myObjectTypesToCollideWith;
 
   //! \brief Predicate for filtering objects by their types
   DtCompositePredicate myCollideableObjectTypesPredicate;
 
   //! \brief Mutex for thread-safe access to data structures
   tbb::spin_mutex myMutex;
};
 
} // namespace makVre