vortexIntegrationModule.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2024 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file    vortexIntegrationModule.h
//! \brief   Integration module for connecting VR-Forces with the Vortex physics engine
//! \ingroup vreVrfVortex
 
#pragma once
 
#include <vreVrfVortex/export.h>
 
#include <VxSim/VxSmartInterface.h>
#include <VxSim/ISimulatorModule.h>
#include <VxSim/EventManager.h>
#include <VxSim/EventData.h>
#include <VxSim/VxApplicationMode.h>
 
#include <deque>
 
namespace VxContent
{
class Scene;
}
 
namespace VxDynamics
{
class Mechanism;
}
 
namespace VxSim
{
class VxApplication;
}
 
namespace makVre
{
//! \brief Simulator module that integrates VR-Forces with the Vortex physics engine
//!
//! This module manages the communication between VR-Forces and the Vortex physics engine.
//! It handles the synchronization of extension updates and parts updates, allowing for
//! controlled modification of Vortex entities during simulation.
class VREVRFVORTEX_DLL DtVxSimModule : public VxSim::ISimulatorModule
{
public:
   //! \brief Factory key for the DtVxSimModule
   //!
   //! Unique identifier used to register and create instances of this module.
   static const VxSim::VxFactoryKey kModuleKey;
 
   //! \brief Event ID for extension update operations
   //!
   //! Used to register and trigger extension update events.
   static const VxSim::EventId kExtensionUpdate;
 
   //! \brief Event ID for parts update operations
   //!
   //! Used to register and trigger parts update events.
   static const VxSim::EventId kPartsUpdate;
 
   //! \brief Operation types that can be queued for processing
   enum class Operation
   {
      PARTS_UPDATE = 0, //!< Update operation for Vortex parts
      EXTENSION_UPDATE  //!< Update operation for Vortex extensions
   };
 
   //! \brief Pair of operation type and event data for queued operations
   using OperationEvent = std::pair<Operation, VxSim::EventData>;
 
public:
   //! \brief Constructor
   //!
   //! Initializes the module with the provided simulator module proxy.
   //!
   //! \param iProxy Pointer to the simulator module proxy
   DtVxSimModule(VxSim::VxSimulatorModule* iProxy);
 
   //! \brief Destructor
   virtual ~DtVxSimModule() override;
 
   //! \brief Handles application mode changes
   //!
   //! Called when the Vortex application transitions between modes (e.g., edit mode, simulation mode).
   //!
   //! \param previous Previous application mode
   //! \param next New application mode
   virtual void onApplicationModeChange(VxSim::eApplicationMode previous, VxSim::eApplicationMode next) override;
 
   //! \brief Called when this module is added to the Vortex application
   //!
   //! Registers event listeners for extension and parts update events.
   //!
   //! \param application Pointer to the Vortex application
   virtual void onAddToApplication(VxSim::VxApplication* application) override;
 
   //! \brief Called when this module is removed from the Vortex application
   //!
   //! Unregisters event listeners and performs cleanup.
   //!
   //! \param application Pointer to the Vortex application
   virtual void onRemoveFromApplication(VxSim::VxApplication* application) override;
 
   //! \brief Called before each simulation update
   //!
   //! Processes a limited number of queued operations per frame to avoid performance issues.
   //!
   //! \param mode Current application mode
   virtual void onPreUpdate(VxSim::eApplicationMode mode) override;
 
protected:
   //! \brief Processes an extension update operation
   //!
   //! Enables or disables a Vortex extension based on the event data.
   //!
   //! \param data Event data containing extension information and enable/disable flag
   void processExtensionUpdate(const VxSim::EventData& data);
 
   //! \brief Callback for extension update events
   //!
   //! Queues extension update operations for processing.
   //!
   //! \param data Event data for the extension update
   void extensionUpdateCallback(const VxSim::EventData& data);
 
   //! \brief Processes a parts update operation
   //!
   //! Updates the control type of Vortex parts based on the event data.
   //!
   //! \param data Event data containing part information and control type
   void processPartsUpdate(const VxSim::EventData& data);
 
   //! \brief Callback for parts update events
   //!
   //! Queues parts update operations for processing.
   //!
   //! \param data Event data for the parts update
   void partsUpdateCallback(const VxSim::EventData& data);
 
protected:
   std::deque<OperationEvent> myQueuedOperations;  //!< Queue of operations to be processed
 
   int myNumberOfOperationsPerFrame;               //!< Maximum number of operations to process per frame
 
   VxSim::EventListener myExtensionUpdateListener; //!< Listener for extension update events
   VxSim::EventListener myPartsUpdateListener;     //!< Listener for parts update events
};
} // namespace makVre