savedViewUpdater.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file savedViewUpdater.h
//! \brief Component for managing predefined observer views and positions in vehicles
//! \ingroup vreCommonComponents
 
 
#pragma once
 
#include "vreCommonComponents/export.h"
#include "vreCommonComponents/observerUpdater.h"
#include "vreCommonComponents/stateDefines.h"
 
#include "vreMessageManager/vreMessage.h"
 
#include <vrvCore/DtUniqueID.h>
#include <vlutil/vlFilename.h>
 
#include <makArchives/DtObserverStateRecordsList.h>
 
namespace makVrv
{
class DtDe;
class DtEntityFacade;
class DtObserver;
class DtChannel;
class DtSceneObject;
}; // namespace makVrv
 
namespace SavedViewUpdaterConfig
{
//! \ingroup RoleConfigParams
//! \defgroup SavedViewUpdaterRoleParams Saved View Updater Role Parameters
//! \roleInherits{ObserverUpdaterRoleParams}
//! Configuration Options for saved view updater role.
//! @{
 
//! \vreRoleParam{allowChangingViews,bool,true,savedViewUpdater,Determines whether the player is allowed to change between saved views.}
constexpr const char* allowChangingViews = "allowChangingViews";
 
//! \vreRoleParam{channelName,string,"Channel 1",savedViewUpdater,Name of the channel to update with view keywords.}
constexpr const char* channelName = "channelName";
 
//! \vreRoleParam{hideHumanInSavedViews,table,"",savedViewUpdater,Table specifying which saved views should hide the human model during walk-on embarkation.}
constexpr const char* hideHumanInSavedViews = "hideHumanInSavedViews";
 
//! \vreRoleParam{initialView,string,"",savedViewUpdater,Name of the initial saved view to activate on startup.}
constexpr const char* initialView = "initialView";
 
//! \vreRoleParam{observerName,string,"Observer 1",savedViewUpdater,Name of the observer to use for saved view management.}
constexpr const char* observerName = "observerName";
 
//! \vreRoleParam{savedViews,string,"",savedViewUpdater,Path to the file containing saved view definitions.}
constexpr const char* savedViews = "savedViews";
 
//! \vreRoleParam{showCockpits,bool,false,savedViewUpdater,Determines whether cockpit models should be visible in saved views.}
constexpr const char* showCockpits = "showCockpits";
 
//! \vreRoleParam{viewChannelKeywordMap,table,"",savedViewUpdater,Table mapping saved view names to channel keywords for view-specific display settings.}
constexpr const char* viewChannelKeywordMap = "viewChannelKeywordMap";
 
//! \vreRoleParam{windowName,string,"Window 1",savedViewUpdater,Name of the window containing the channel to update.}
constexpr const char* windowName = "windowName";
 
//! @}
} // namespace SavedViewUpdaterConfig
 
namespace makVre
{
class DtSavedViewInputLogic;
 
//! \brief Type identifier for DtSavedViewUpdater component
constexpr const char* DtSavedViewUpdaterType = "DtSavedViewUpdater";
 
//! \brief Component for managing predefined observer views and positions in vehicles
//!
//! DtSavedViewUpdater loads and manages a set of saved viewpoints for a vehicle or role,
//! allowing the player to switch between different positions (driver, gunner, etc.)
//! and sensor modes (visual, NVG, thermal). It handles observer attachment, view positioning,
//! human model visibility, and channel configuration for each view.
class VRECOMMONCOMPONENTS_DLL DtSavedViewUpdater : public makVre::DtObserverUpdater
{
public:
   //! \brief Constructor for DtSavedViewUpdater
   //!
   //! Initializes the saved view updater with default settings
   DtSavedViewUpdater();
 
   //! \brief Virtual destructor for DtSavedViewUpdater
   virtual ~DtSavedViewUpdater() override;
 
   //! \brief Initializes the saved view updater component
   //! \param player Pointer to the player station this component belongs to
   //! \param config Configuration table containing saved view settings
   //! \return True if initialization succeeded, false otherwise
   //!
   //! Sets up the saved view system, loads view definitions from a file, configures
   //! input handlers, and establishes observer attachment parameters
   virtual bool initialize(makVre::DtPlayerStation* player, makVre::DtInitTable& config) override;
   //! \brief Called every frame to update the saved view system
   //! \param dt Delta time since the last frame in seconds
   //!
   //! Updates sensor modes, handles view orientation adjustments for VR,
   //! and manages destruction state changes
   virtual void tick(double dt) override;
   //! \brief Shuts down the saved view updater component
   //!
   //! Restores human model visibility to its original state, disconnects message handlers,
   //! shuts down input logic, and resets observer attachments
   virtual void shutdown() override;
 
   //! \brief Returns the type identifier for this component
   //! \return The type string for DtSavedViewUpdater
   virtual const char* type() const override;
 
   //! \brief Gets the input logic component for saved views
   //! \return Shared pointer to the saved view input logic component
   //!
   //! Provides access to the input logic component that handles saved view input bindings
   std::shared_ptr<DtSavedViewInputLogic> getInputLogic();
 
   //! \brief Switches to a specific saved view by index
   //! \param viewIndex Index of the view to activate
   //!
   //! Changes the observer's position and orientation to the specified saved view,
   //! updates channel keywords, and handles human model visibility
   virtual void gotoView(unsigned int viewIndex);
 
   //! \brief Switches to the next saved view in sequence
   //!
   //! Increments the current view index and activates that view
   virtual void nextView();
 
   //! \brief Switches to the previous saved view in sequence
   //!
   //! Decrements the current view index and activates that view
   virtual void previousView();
 
   //! \brief Toggles between a named view and a previously active view
   //! \param viewName Name of the view to toggle to/from
   //! \param allowPartialMatch If true, allows partial matching of view names
   //!
   //! If the named view is not the current view, sets myViewToReturnTo to the current view
   //! and switches to the named view. If the named view is already the current view and
   //! myViewToReturnTo is valid, switches back to the previously stored view.
   //! Note: myViewToReturnTo is reset to -1 by gotoView.
   virtual void toggleView(const std::string& viewName, bool allowPartialMatch);
 
   //! \brief Gets the observer being managed by this component
   //! \return Pointer to the observer object
   //!
   //! Provides access to the VRV observer object for direct manipulation
   makVrv::DtObserver* getObserver();
 
 
   //! \brief Loads saved views from a file
   //! \param filename Path to the file containing saved view definitions
   //!
   //! Reads and processes observer state records from the specified file
   virtual void loadSavedViews(DtFilename filename);
 
   //! \brief Gets the list of loaded saved view records
   //! \return List of observer state records representing the saved views
   //!
   //! Provides access to the cached observer state records loaded from the file
   virtual makArchives::DtObserverStateRecordsList getSavedViewsRecords();
 
   //! \brief Gets the filename of the currently loaded saved views file
   //! \return Filename of the saved views file
   //!
   //! Returns the path to the file from which saved views were loaded
   virtual DtFilename getSavedViewsFileName();
 
protected:
   //! \brief Handles menu action messages related to saved views
   //! \param msg The menu action message
   //! \return Message handling result indicating if the message was handled
   //!
   //! Processes menu actions for next/previous view and explicit view selection
   virtual makVre::DtVreMessageResult handleMenuMessage(makVre::DtVreMessage* msg);
 
   //! \brief Updates channel keywords based on the current view name
   //! \param viewName Name of the current view
   //!
   //! Applies or removes channel keywords based on the view-to-keyword mapping
   void updateChannelForViewName(const std::string& viewName);
 
   //! \brief Updates the observer's sensor mode based on current state
   //!
   //! Changes the observer's sensor based on the currentSensor attribute,
   //! handling transitions between visual, NVG, and thermal modes
   void updateSensor();
 
   //! \brief Updates view settings when the vehicle is destroyed
   //!
   //! Handles special cases for observer settings when damage state is "destroyed"
   void updateDestroyed();
 
   //! \brief Handles player creation messages
   //! \param msg The player created message
   //! \return Message handling result indicating if the message was handled
   //!
   //! Calls setupObserver() to establish the observer attachment details
   //! when the player entity is created in the simulation
   virtual makVre::DtVreMessageResult handlePlayerCreated(makVre::DtVreMessage* msg);
 
   //! \brief Sets up the observer attachment configuration
   //!
   //! Configures the observer with AttachTypeMimic attachment to the player entity
   //! and activates the initial view specified in the configuration
   virtual void setupObserver();
 
   //! \brief Determines if the human model should be hidden for a specific view
   //! \param viewName Name of the view to check
   //! \return True if the human model should be hidden, false otherwise
   //!
   //! Checks if the specified view is in the list of views that should hide
   //! the human model (relevant for walk-on embarkation)
   virtual bool shouldHideHumanModel(std::string viewName) const;
 
   //! \brief Shows the human model if it exists
   //!
   //! Makes the human model visible by sending a visibility message
   virtual void showHumanModel();
 
   //! \brief Hides the human model if it exists
   //!
   //! Makes the human model invisible by sending a visibility message
   virtual void hideHumanModel();
 
   //! \brief Finds the human player station if walk-on embarkation was used
   //! \return Pointer to the human player station if found, nullptr otherwise
   //!
   //! Locates the suspended human player station that corresponds to this vehicle role
   //! when the player has performed walk-on embarkation
   virtual DtPlayerStation* findHumanPlayer() const;
 
   //! \brief Slot called when the human scene object is about to be deleted
   //! \param id Unique ID of the scene object being deleted
   //!
   //! Clears the human scene object reference when the object is destroyed
   virtual void slot_disSceneObjectToBeDeleted(const makVrv::DtUniqueID& id);
 
   //! \brief Provides an interactive ImGui debug interface for saved views management
   //!
   //! Creates a collapsible debug panel that displays the current saved views file,
   //! lists all available views (selectable to switch views), and provides interactive
   //! controls for real-time adjustment of observer position and rotation offsets.
   //! Also includes functionality to save modified views back to the file or create
   //! new saved view files. Used by the VRE debug system for saved view development
   //! and troubleshooting.
   virtual void debugSavedViews();
 
protected:
   //! \brief Input logic component that handles saved view input bindings
   std::shared_ptr<DtSavedViewInputLogic> myInputLogic;
 
   //! \brief Pointer to the observer being managed by this component
   makVrv::DtObserver* myObserver;
 
   //! \brief Index of the currently active saved view
   int myCurrentView;
 
   //! \brief Index of the view to return to when toggling views
   int myViewToReturnTo;
 
   //! \brief Total number of available saved views
   int myNumViews;
 
   //! \brief Name of the gunner seat view
   std::string myGunnerSeatView;
 
   //! \brief Flag indicating if the current view is a gunner seat view
   bool myInGunnerSeat;
 
   //! \brief Last sensor view mode that was applied
   SensorViews myLastSensorViewMode;
 
   //! \brief Names of the saved views
   std::vector<std::string> mySavedViews;
 
   //! \brief Type definition for mapping view names to channel keywords
   using ViewChannelKeywordMap = std::map<std::string, std::string>;
 
   //! \brief Mapping from view names to channel keywords
   ViewChannelKeywordMap myViewChannelKeywordMap;
 
   //! \brief List of channel keywords applied for the current view
   std::vector<std::string> myLastChannelKeywords;
 
   //! \brief Index of the initial view to activate on startup
   int myInitialView;
 
   //! \brief Flag indicating if view changes are allowed
   bool myAllowChangingViews;
 
   //! \brief Flag indicating if the model should be hidden
   bool myHideModel;
 
   //! \brief Name of the observer to use
   std::string myObserverName;
 
   //! \brief Name of the channel to update with view keywords
   std::string myChannelName;
 
   //! \brief Name of the window containing the channel
   std::string myWindowName;
 
   //! \brief Path to the file containing saved view definitions
   DtFilename mySavedViewsFileName;
 
   //! \brief List of observer state records loaded from the saved views file
   makArchives::DtObserverStateRecordsList myCachedObserverViews;
 
   //! \brief List of view names for which the human model should be hidden
   std::vector<std::string> myHideHumanModelInSavedViews;
 
   //! \brief Pointer to the human scene object for walk-on embarkation
   makVrv::DtSceneObject* myHumanSceneObject;
 
   //! \brief Initial visibility state of the human scene object
   bool myHumanSceneObjectInitiallyVisible;
};
} // namespace makVre