objectProximitySensor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file objectProximitySensor.h
//! \ingroup vreVrfmodel
//! \brief Proximity sensor for detecting objects within a specified range
//!
//! This file defines the DtObjectProximitySensor class which extends the base
//! proximity sensor to detect specific objects within a configurable detection range.
//! It provides functionality to monitor and report on objects that enter and exit
//! the sensor's detection area.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include "vreVrfmodel/vreSimComponent.h"
 
#include <vrfmodel/simpleProximitySensor.h>
#include <vrfutil/rwSensorContactInfo.h>
 
//! \brief Sensor type enumeration value for proximity sensors
//!
//! This value is used to identify proximity sensors when requesting sensor updates
//! in the front-end systems.
static const DtSensorTypeEnum DtProximitySensorType = static_cast<DtSensorTypeEnum>(50);
 
//! \brief Type identifier string for object proximity sensor components
static const char* DtObjectProximitySensorType = "object-proximity-sensor";
 
namespace makVre
{
class DtObjectProximitySensorMonitor;
 
//! \brief Component that detects objects within a specified distance range
//!
//! DtObjectProximitySensor extends the base proximity sensor to detect
//! specific objects that come within a configurable detection range.
//! It provides notifications when objects enter or exit the sensor's range,
//! and maintains a list of currently detected objects. The component also
//! supports integration with front-end visualization systems and provides
//! Lua bindings for scripting access.
class VREVRFMODEL_DLL DtObjectProximitySensor : public DtVreSimComponent<DtSimpleProximitySensor>
{
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtObjectProximitySensor();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtObjectProximitySensor(const DtObjectProximitySensor& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtObjectProximitySensor& operator=(const DtObjectProximitySensor& orig);
 
public:
   //! \brief Constructor
   //! \param name The name of this component
   //! \param owner The local object that owns this component
   //! \param simManager The simulation services manager
   //! \param desc Optional component descriptor with configuration parameters
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //!
   //! Creates a new object proximity sensor component with the specified parameters.
   DtObjectProximitySensor(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the object proximity sensor component,
   //! including the sensor monitor.
   virtual ~DtObjectProximitySensor() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtObjectProximitySensorType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   //! \brief Initializes the component
   //! \return True if initialization is successful, false otherwise
   //!
   //! Performs component initialization, setting up the sensor monitor
   //! and configuring detection parameters based on the component descriptor.
   virtual bool init() override;
 
   //! \brief Updates the sensor state each simulation frame
   //!
   //! Processes sensor detection logic each frame, but only if the simulation
   //! is not paused. Detects objects that have entered or exited the sensor's
   //! range and updates the sensor monitor accordingly.
   virtual void tick() override;
 
   //! \brief Disables the sensor component
   //!
   //! Overridden to clear out the target list and update the monitor when the
   //! sensor is disabled, ensuring the sensor contact list is properly cleared
   //! in the front-end visualization.
   virtual void disable() override;
 
   //! \brief Sets the enabled state of the sensor component
   //! \param yesNo True to enable the sensor, false to disable it
   //!
   //! Overridden to properly handle the sensor's enabled state, ensuring that
   //! the target list and monitor are updated appropriately when the state changes.
   virtual void setIsEnabled(bool yesNo) override;
 
   //! \brief Factory method to create a new instance of this component
   //! \param name The name for the new component
   //! \param owner The local object that will own this component
   //! \param simManager The simulation services manager
   //! \param desc Optional component descriptor
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //! \return Pointer to the newly created component
   //!
   //! Static factory method used by the component creation system to instantiate
   //! new instances of this component type.
   static DtSimComponent* creator(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
protected:
   //! \brief Creates and initializes the sensor monitor
   //! \return True if monitor creation and initialization succeeds, false otherwise
   //!
   //! Creates a DtObjectProximitySensorMonitor instance and initializes it,
   //! establishing the connection between the sensor and the front-end
   //! visualization system.
   virtual bool createAndInitSensorMonitor();
 
   //! \brief Processes detected objects in the sensor's range
   //! \return True if the status of any detected objects changed, false otherwise
   //!
   //! Performs detection checks for objects within the sensor's range, updating
   //! the list of detected objects and notifying the sensor monitor of any changes.
   virtual bool processObjects();
 
   //! \brief Processes dynamic terrain objects for detection
   //! \param contactNames Set of UUIDs for contact objects being tracked
   //! \param searchFor String pattern to search for in dynamic terrain objects
   //! \param sendAsType Entity type to use when reporting detections
   //! \return True if any dynamic terrain objects were detected, false otherwise
   //!
   //! Searches for dynamic terrain objects matching the specified pattern and
   //! adds them to the sensor's detection list when found within range.
   virtual bool processDynamicTerrainObjects(
      std::set<DtUUID>& contactNames, std::string searchFor, DtEntityType sendAsType);
 
protected:
   //! \brief Pointer to the sensor monitor
   //!
   //! The monitor object that handles communication between the sensor and
   //! the front-end visualization system. Maintains the list of detected
   //! objects and their properties for display.
   DtObjectProximitySensorMonitor* myMonitor;
};
 
} // namespace makVre