vortexPhysicalWorld.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2024 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vortexPhysicalWorld.h
//! \brief Contains DtVortexPhysicalWorld class that manages the Vortex physics simulation environment
//! \ingroup vreVrfVortex
 
#pragma once
 
#include <vreVrfVortex/export.h>
 
#include <vrfobjcore/physicalWorld.h>
 
#include <Vx/VxUniverse.h>
 
#include <VxSim/VxSmartInterface.h>
#include <VxSim/IMaterialTable.h>
#include <VxSim/VxSimulationState.h>
 
#include <VxPluginSystem/VxPluginManagerListener.h>
 
#include "vreUtil/vreThreadPool.h"
#include "vreUtil/coordConverter.h"
 
class DtCgf;
class DtLocalObjectManager;
class DtSimulationServices;
class DtScenario;
 
namespace VxContent
{
class Scene;
}
 
namespace makVre
{
class DtInitializer;
class DtVortexCollisionProxyGenerator;
class DtVortexDebug;
class DtVortexDynamicTerrainHandler;
class DtVortexPagedTerrainProducer;
class DtVortexPagedTerrainInterface;
class DtVxSimModule;
 
class DtVxPluginManagerListener;
 
//! \brief Main class responsible for managing the Vortex physics simulation environment
//!
//! DtVortexPhysicalWorld handles the initialization, management, and execution of the
//! Vortex physics engine within the simulation. It manages terrain, collision detection,
//! and physics simulation updates.
class VREVRFVORTEX_DLL DtVortexPhysicalWorld : public DtPhysicalWorld
{
public:
   //! \brief Constructs a new Vortex physical world
   //! \param simManager Pointer to the simulation services manager
   //! \param localObjManager Pointer to the local object manager
   //! \param cgf Pointer to the CGF instance
   explicit DtVortexPhysicalWorld(DtSimulationServices* simManager, DtLocalObjectManager* localObjManager, DtCgf* cgf);
 
   //! \brief Virtual destructor
   virtual ~DtVortexPhysicalWorld() override;
 
   //! \brief Gets the singleton instance of the Vortex Physical World
   //! \return Pointer to the DtVortexPhysicalWorld instance
   static DtVortexPhysicalWorld* instance();
 
   //! \brief Main update function for the physics simulation
   //!
   //! Updates the Vortex Application, VortexDebug, VortexCollisionProxyGenerator,
   //! and VortexDynamicTerrainHandler components.
   virtual void tick() override;
 
   //! \brief Gets the Vortex application instance
   //! \return Smart pointer to the VxApplication
   Vx::VxSmartPtr<VxSim::VxApplication> vortexApplication();
 
   //! \brief Gets the Vortex scene instance
   //! \return Smart interface to the Scene
   VxSim::VxSmartInterface<VxContent::Scene> vortexScene();
 
   //! \brief Gets the configuration initializer
   //! \return Pointer to the DtInitializer instance
   makVre::DtInitializer* configInitializer();
 
   //! \brief Gets the geocentric coordinate converter
   //! \return Pointer to the coordinate converter, NULL if using flat earth/UTM/topographic terrain
   makVre::DtCoordinateConvert* geocentricCoordConverter();
 
   //! \brief Updates the coordinate converter based on different conditions
   //! Called from \sa processPostLoadScenario with a list of entities.
   //!   If there are local, vortex entities loaded: Gets the average position of them all and calls \sa
   //!   updateCoordinateConverterFromGeocentric() If there are no entities above, then waits for first vortex entity
   //!   created and then sets the origin at that location.
   virtual void updateCoordinateConverter();
 
   //! \brief Sets the Vortex universe instance
   //! \param universe Pointer to the VxUniverse to set
   virtual void setUniverse(Vx::VxUniverse* universe);
 
   //! \brief Gets the current Vortex universe instance
   //! \return Pointer to the current VxUniverse
   virtual Vx::VxUniverse* getUniverse();
 
   //! \brief Sets the paged terrain producer
   //! \param producer Pointer to the terrain producer instance
   virtual void setPagedTerrainProducer(DtVortexPagedTerrainProducer* producer);
 
   //! \brief Gets the current paged terrain producer
   //! \return Pointer to the current terrain producer
   virtual DtVortexPagedTerrainProducer* pagedTerrainProducer();
 
   //! \brief Sets the paged terrain interface
   //! \param pagedTerrainInterface Pointer to the terrain interface
   virtual void setPagedTerrain(DtVortexPagedTerrainInterface* pagedTerrainInterface);
 
   //! \brief Gets the current paged terrain interface
   //! \return Pointer to the current terrain interface
   virtual DtVortexPagedTerrainInterface* pagedTerrain();
 
   //! \brief Gets the dynamic terrain handler
   //! \return Shared pointer to the terrain handler
   virtual std::shared_ptr<makVre::DtVortexDynamicTerrainHandler> vortexDynamicTerrainHandler();
 
   //! \brief Sets the dynamic terrain handler
   //! \param handler Shared pointer to the new terrain handler
   virtual void setVortexDynamicTerrainHandler(std::shared_ptr<makVre::DtVortexDynamicTerrainHandler> handler);
 
   //! \brief Gets the collision proxy generator
   //! \return Pointer to the collision proxy generator
   //! \note Returns NULL if enableNonVortexToVortexCollisions is false in vortexConfig.lua
   virtual makVre::DtVortexCollisionProxyGenerator* getCollisionProxyGenerator();
 
   //! \brief Gets the local object manager
   //! \return Pointer to the local object manager
   virtual DtLocalObjectManager* localObjectManager();
 
   //! \brief Gets the debug interface
   //! \return Shared pointer to the debug interface
   virtual std::shared_ptr<DtVortexDebug> vortexDebug();
 
   //! \brief Gets the thread pool for paged terrain
   //! \return Shared pointer to the thread pool
   virtual std::shared_ptr<DtVreThreadPool> threadPool();
 
   //! \brief Gets the material table
   //! \return Pointer to the material table
   virtual Vx::VxMaterialTable* getMaterialTable();
 
   //! \brief Checks if the CGF is being destroyed
   //! \return true if CGF is in process of destruction, false otherwise
   bool isDestructingCGF();
 
   //! \brief Gets the distance to check to the coordinate origin.
   //! Distance is in km. Set in the vortexConfig.lua
   //! \return the distance (km)
   double checkDistanceToCoordinateOrigin() const;
 
   //! \brief The distance to check for how the vehicle from the coordinate origin.
   //! Distance is in km. Set in the vortexConfig.lua by default
   //! \param val distance (km)
   void setCheckDistanceToCoordinateOrigin(double val);
 
   //! \brief Check for how far we are from the coordinate origin.
   //! Purely informational check, provides no simulation impact.
   //! \return true if we should do our check
   bool checkToCoordinateOrigin() const;
 
   //! \brief Set for Check distance from origin.
   //! \param val
   void setCheckToCoordinateOrigin(bool val);
 
protected:
   //! \brief Updates the geocentric coordinate converter to a new position
   //! Given a new world position, reinitializes the coordinate converter to reference the passed in point
   //! as your new 0,0,0 in flat earth coordinates.
   //! \param worldPos The world location in GeocentricCoordinates
   virtual void updateCoordinateConverterFromGeocentric(const DtVector& worldPos);
 
   //! \brief Updates the physics universe settings
   //! \param univ Pointer to the universe to update
   virtual void updateUniverseSettings(Vx::VxUniverse* univ);
 
   //! \brief Resets the Vortex application to its initial state
   virtual void resetVortexApplication();
 
   //! \brief Starts the Vortex application
   virtual void runVortexApplication();
 
   //! \brief Pauses the Vortex application
   virtual void pauseVortexApplication();
 
   //! \brief Updates Vortex until a condition is met
   //! \param func Function returning bool that determines when to stop updating
   virtual void updateVortex(const std::function<bool(void)> func);
 
   //! \brief Updates Vortex until a specific application mode is reached
   //! \param targetMode The target application mode
   virtual void updateVortex(VxSim::eApplicationMode targetMode);
 
   //! \brief Initializes the Vortex application
   virtual void initializeVortexApplication();
 
   //! \brief Initializes the collision manager
   //! \param cgf Pointer to the CGF instance
   //! \return true if initialization successful, false otherwise
   virtual bool initializeCollisionManager(DtCgf* cgf);
 
   // Callback methods and their processors
   //! \brief Static callback for pre-scenario rollback events
   //! \param data Pointer to user data (typically the DtVortexPhysicalWorld instance)
   static void preScenarioRollbackCallback(void* data);
 
   //! \brief Processes pre-scenario rewind events
   virtual void processPreScenarioRewindCallback();
 
   //! \brief Static callback for post-scenario rollback events
   //! \param data Pointer to user data (typically the DtVortexPhysicalWorld instance)
   static void postScenarioRollbackCallback(void* data);
 
   //! \brief Processes post-scenario rewind events
   virtual void processPostScenarioRewindCallback();
 
   //! \brief Static callback for pre-load scenario events
   //! \param scenario Reference to the scenario being loaded
   //! \param data Pointer to user data (typically the DtVortexPhysicalWorld instance)
   static void preLoadScenarioCallback(DtScenario& scenario, void* data);
 
   //! \brief Processes pre-load scenario events
   virtual void processPreLoadScenario();
 
   //! \brief Static callback for post-load scenario events
   //! \param scenario Reference to the loaded scenario
   //! \param data Pointer to user data (typically the DtVortexPhysicalWorld instance)
   static void postLoadScenarioCallback(const DtScenario& scenario, void* data);
 
   //! \brief Processes post-load scenario events
   virtual void processPostLoadScenario();
 
   //! \brief Static callback for pre-load terrain events
   //! \param scenario Filename of the scenario being loaded
   //! \param data Pointer to user data (typically the DtVortexPhysicalWorld instance)
   static void preLoadTerrainCallback(const DtFilename& scenario, void* data);
 
   //! \brief Processes pre-load terrain events
   virtual void processPreLoadTerrain();
 
   //! \brief Static callback for post-load terrain events
   //! \param terrain Filename of the loaded terrain
   //! \param data Pointer to user data (typically the DtVortexPhysicalWorld instance)
   static void postLoadTerrainCallback(const DtFilename& terrain, void* data);
 
   //! \brief Processes post-load terrain events
   virtual void processPostLoadTerrain();
 
   //! \brief Static callback for pre-close scenario events
   //! \param data Pointer to user data (typically the DtVortexPhysicalWorld instance)
   static void preCloseScenarioCallback(void* data);
 
   //! \brief Processes pre-close scenario events
   virtual void processPreCloseScenarioCallback();
 
   //! \brief Static callback for post-close scenario events
   //! \param data Pointer to user data (typically the DtVortexPhysicalWorld instance)
   static void postCloseScenarioCallback(void* data);
 
   //! \brief Processes post-close scenario events
   virtual void processPostCloseScenarioCallback();
 
   //! \brief Static callback for scenario run events
   //! \param data Pointer to user data (typically the DtVortexPhysicalWorld instance)
   static void scenarioRunCallback(void* data);
 
   //! \brief Processes scenario run events
   virtual void processScenarioRunCallback();
 
   //! \brief Static callback for scenario pause events
   //! \param data Pointer to user data (typically the DtVortexPhysicalWorld instance)
   static void scenarioPauseCallback(void* data);
 
   //! \brief Processes scenario pause events
   virtual void processScenarioPauseCallback();
 
   //! \brief Static callback for post-tick initialization events
   //! \param data Pointer to user data (typically the DtVortexPhysicalWorld instance)
   static void postTickInitCallback(void* data);
 
   //! \brief Processes post-tick initialization events
   virtual void processPostTickInitCallback();
 
   //! \brief Static callback for CGF destruction events
   //! \param data Pointer to user data (typically the DtVortexPhysicalWorld instance)
   static void cgfAboutToBeDestroyed(void* data);
 
   //! \brief Processes CGF destruction events
   virtual void processCgfAboutToBeDestroyed();
 
   //! \brief Static callback for ImGui rendering events
   //! \param args Pointer to arguments for the callback
   static void renderImguiCallback(void* args);
 
   //! \brief Updates ImGui interface elements
   virtual void updateImgui();
 
protected:
   //! \brief Flag indicating if CGF is being destroyed
   bool myDestructingCGF;
 
   //! \brief Singleton instance of the physical world
   static DtVortexPhysicalWorld* thePhysicalWorld;
 
   //! \brief Pointer to the CGF instance
   DtCgf* myCgf;
 
   //! \brief Collision proxy generator for handling collisions
   makVre::DtVortexCollisionProxyGenerator* myVortexCollisionManager;
 
   // Vortex values
   //! \brief Material table for physics interactions
   VxSim::VxSmartInterface<VxSim::IMaterialTable> myMaterialTable;
 
   //! \brief Vortex simulation module
   VxSim::VxSmartInterface<DtVxSimModule> myModule;
 
   //! \brief Terrain extension for Vortex
   Vx::VxSmartPtr<VxSim::VxExtension> myTerrainExt;
 
   //! \brief Vortex scene interface
   VxSim::VxSmartInterface<VxContent::Scene> myScene;
 
   //! \brief Vortex application instance
   Vx::VxSmartPtr<VxSim::VxApplication> myApplication;
 
   //! \brief Simulation state for Vortex
   Vx::VxSmartPtr<VxSim::VxSimulationState> mySimulationState;
 
   //! \brief Producer for paged terrain
   DtVortexPagedTerrainProducer* myPagedTerrainProducer;
 
   //! \brief Interface for paged terrain
   DtVortexPagedTerrainInterface* myPagedTerrainInterface;
 
   //! \brief Vortex universe instance
   Vx::VxUniverse* myUniverse;
 
   //! \brief Plugin manager listener
   std::shared_ptr<DtVxPluginManagerListener> myListener;
 
   //! \brief Thread pool for parallel processing
   std::shared_ptr<DtVreThreadPool> myThreadPool;
 
   //! \brief Configuration initializer
   makVre::DtInitializer* myConfigInitializer;
 
   //! \brief Coordinate converter for transformations
   makVre::DtCoordinateConvert myCoordConverter;
   bool myOverrideCoordinateConverterLocation;
   boost::signals2::connection myFirstObjectCreatedConnection;
 
   //! \brief Debug interface for Vortex
   std::shared_ptr<DtVortexDebug> myVortexDebug;
 
   //! \brief Handler for dynamic terrain
   std::shared_ptr<makVre::DtVortexDynamicTerrainHandler> myDynamicTerrainHandler;
 
   //! \brief
   double myCheckDistanceToCoordinateOrigin;
   bool myCheckToCoordinateOrigin;
};
 
 
//! \brief Listener interface for Vortex plugin manager events
//!
//! DtVxPluginManagerListener implements the VxPluginManagerListener interface to
//! receive notifications about plugin manager events, such as plugin initialization.
class DtVxPluginManagerListener : public VxPluginSystem::VxPluginManagerListener
{
public:
   //! \brief Constructor
   DtVxPluginManagerListener();
 
   //! \brief Destructor
   //!
   //! Destroys the listener and unregisters it from the plugin manager.
   virtual ~DtVxPluginManagerListener() override;
 
   //! \brief Called before a plugin is initialized
   //! \param pluginInfo Information about the plugin being initialized
   //! \return true to allow initialization, false to abort
   //! \see VxPluginManager::load
   virtual bool onAboutToInitialize(const VxPluginSystem::VxPluginInfo& pluginInfo) override;
 
protected:
   //! \brief Set of plugin names to ignore
   std::set<std::string> myIgnoredNames;
};
} // namespace makVre