DtVreSensorFieldOfViewManager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file DtVreSensorFieldOfViewManager.h
//! \brief Defines the VR-Engage sensor field of view manager
//!
//! This file contains the DtVreSensorFieldOfViewManager class which extends the
//! base DtSensorFieldOfViewManager to provide VR-Engage-specific behavior for
//! managing sensor field of view states, associated observers, and sensor views.
//! \ingroup vrvCore
 
#pragma once
 
#include "vrePlayerStation/export.h"
#include <vrvCore/vrvCore.h>
#include <vrvCore/DtSensorFieldOfViewManager.h>
#include <vrvCore/DtSensorFieldOfViewData.h>
 
#include <vreMessageManager/vreMessage.h>
 
 
namespace makVrv
{
//! \brief Forward declaration of the observer class
class DtObserver;
 
//! \brief Forward declaration of the sensor view overlay class
class DtSensorViewOverlay;
} // namespace makVrv
 
namespace makVre
{
//! \brief VR-Engage sensor field of view manager
//!
//! DtVreSensorFieldOfViewManager extends the base DtSensorFieldOfViewManager
//! to provide VR-Engage-specific behavior for managing sensor field of view
//! states and the observers associated with them. This includes handling
//! target object position updates, processing tracked locations, managing
//! sensor view windows, and finding appropriate display windows and channels
//! for sensor views.
//! \ingroup vrvCore
class PLAYERSTATION_DLL DtVreSensorFieldOfViewManager : public makVrv::DtSensorFieldOfViewManager
{
public:
   //! \brief Destructor
   //!
   //! Cleans up resources used by the sensor field of view manager.
   virtual ~DtVreSensorFieldOfViewManager() override;
 
   //! \brief Constructor
   //! \param de Reference to the display engine
   //!
   //! Creates a new sensor field of view manager associated with the
   //! specified display engine. This constructor is technically protected,
   //! as instances should be created through the instance() factory method.
   DtVreSensorFieldOfViewManager(makVrv::DtDe& de);
 
   //! \brief Handles target object position messages
   //! \param msg Pointer to the target object position message
   //! \return Message processing result
   //!
   //! Processes messages containing target object position updates.
   //! Updates the cached position and may trigger sensor view updates.
   virtual makVre::DtVreMessageResult handleTargetObjectPosition(makVre::DtVreMessage* msg);
 
   //! \brief Updates sensor field of view state for a specific sensor
   //! \param hostId Unique ID of the host entity
   //! \param sensorId Unique ID of the sensor
   //! \param observerName Name of the observer to update
   //!
   //! Updates the sensor field of view state for the specified sensor,
   //! which may involve creating or updating sensor views and observers.
   //! Overridden to provide VR-Engage-specific update behavior.
   virtual void update(makVrv::DtUniqueID hostId, makVrv::DtUniqueID sensorId, const std::string& observerName) override;
 
   //! \brief Processes the location of a tracked target
   //! \param observer Pointer to the observer
   //! \param hostEntity Element ID of the host entity
   //! \param relativeLocation Relative location of the tracked target from the host
   //! \param targetLocation Absolute location of the tracked target
   //!
   //! Processes the location of a tracked target relative to the host entity.
   //! This method is overridden to make it public, allowing VR-Engage systems
   //! to directly process track locations when needed.
   virtual void processTrackLocation(makVrv::DtObserver* observer, makVrv::DtElementID hostEntity,
      const DtVector& relativeLocation, const DtVector& targetLocation) override;
 
   //! \brief Finds the display window and channel for an observer
   //! \param observer Pointer to the observer
   //! \param displayName Output parameter for the display name
   //! \param windowName Output parameter for the window name
   //! \param channelName Output parameter for the channel name
   //! \return True if a display window and channel were found, false otherwise
   //!
   //! Finds the appropriate display window and channel for the specified observer.
   //! This method is overridden to make it public, allowing VR-Engage systems
   //! to directly find display windows and channels when needed.
   virtual bool findDisplayWindowAndChannel(const makVrv::DtObserver* observer, std::string& displayName,
      std::string& windowName, std::string& channelName) const override;
 
   //! \brief Removes a sensor view window
   //! \param entId Unique ID of the entity
   //! \param sensorId Unique ID of the sensor
   //!
   //! Removes a sensor view window that has been created for the specified
   //! entity and sensor. This method is overridden because the base class implementation
   //! attempts to delete the window as well, which would also delete channels
   //! associated with it. The VR-Engage implementation provides a safer approach
   //! that avoids unintended channel deletion.
   virtual void removeSensorView(makVrv::DtUniqueID entId, makVrv::DtUniqueID sensorId) override;
 
protected:
   //! \brief Cached position of the last tracked target
   //!
   //! Stores the position of the last tracked target for use in subsequent
   //! calculations or updates. This avoids redundant position calculations
   //! or lookups when the same target is being processed multiple times.
   DtVector myCachedPosition;
};
} // namespace makVre