vehicleOccupantUpdater.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file vehicleOccupantUpdater.h
//! \brief Component for managing vehicle occupant visibility when a player assumes a driver role
//! \ingroup vreCommonComponents
 
#pragma once
 
#include "vreCommonComponents/export.h"
 
#include "vrePlayerStation/playerComponent.h"
 
namespace makVrv
{
class DtDe;
class DtObserver;
} // namespace makVrv
 
namespace makVre
{
//! \brief Type identifier for DtVehicleOccupantUpdater component
constexpr const char* DtVehicleOccupantUpdaterType = "DtVehicleOccupantUpdater";
 
//! \brief Component that manages vehicle occupant visibility during player engagement
//!
//! DtVehicleOccupantUpdater manages the visibility of vehicle occupant models (visual-only
//! representations of drivers in vehicles) when a player assumes a driver role. It caches the
//! current occupant visibility state when a player first takes control and restores that state
//! when the player relinquishes control. During player control, the component ensures the
//! occupant is visible to external observers while hiding it locally for the player to
//! prevent visual obstructions.
 
class VRECOMMONCOMPONENTS_DLL DtVehicleOccupantUpdater : public DtPlayerComponent
{
public:
   //! \brief Constructor for DtVehicleOccupantUpdater
   //!
   //! Initializes the component with default state values
   DtVehicleOccupantUpdater();
 
   //! \brief Virtual destructor for DtVehicleOccupantUpdater
   virtual ~DtVehicleOccupantUpdater() override;
 
   //! \brief Initializes the vehicle occupant updater component
   //! \param player Pointer to the player station this component belongs to
   //! \param config Configuration table containing component settings
   //! \return True if initialization succeeded, false otherwise
   //!
   //! Determines whether the player is an implicit driver (directly controlling a vehicle)
   //! versus an embarked driver (a human player that entered a vehicle)
   virtual bool initialize(DtPlayerStation* player, DtInitTable& config) override;
 
   //! \brief Called every frame to update the occupant visibility state
   //! \param dt Delta time since the last frame in seconds
   //!
   //! If the player is an implicit driver, this function waits until it can detect the
   //! "HideOccupants" state. Once detected, it performs the following actions once:
   //! - Caches the initial occupant visibility state
   //! - Shows the driver occupant externally (to other observers)
   //! - Hides the driver occupant model locally (for the player's view)
   virtual void tick(double dt) override;
 
   //! \brief Shuts down the vehicle occupant updater component
   //!
   //! Restores the driver occupant model locally and resets the published
   //! "HideOccupants" state of the vehicle to its original value
   virtual void shutdown() override;
 
   //! \brief Returns the type identifier for this component
   //! \return The type string for DtVehicleOccupantUpdater
   virtual const char* type() const override;
 
protected:
   //! \brief Makes the driver occupant visible to external observers
   //!
   //! Sends an internal message indicating that the driver occupant for the
   //! vehicle should be visible. This ensures that other simulators and
   //! observers will see the driver model in the vehicle.
   virtual void showDriverOccupantExternally();
 
   //! \brief Makes the driver occupant visible to external observers
   //!
   //! Sends an internal message indicating that the driver occupant for the
   //! vehicle should be hidden. This ensures that other simulators and
   //! observers will hide the driver model in the vehicle.
   virtual void hideDriverOccupantExternally();
 
   //! \brief Hides the driver occupant model in the local view
   //!
   //! Sends a message to hide the occupant model locally, preventing it from
   //! obstructing the player's view while driving
   virtual void hideDriverOccupantLocally();
 
   //! \brief Shows the driver occupant model in the local view
   //!
   //! Sends a message to make the occupant model visible locally,
   //! typically called during shutdown to restore the original state
   virtual void showDriverOccupantLocally();
 
   //! \brief Saves the original occupant visibility state
   //!
   //! Reads and caches the initial "HideOccupants" attribute value
   //! to allow proper restoration during shutdown
   virtual void cacheOccupantState();
 
   //! \brief Restores the original occupant visibility state
   //!
   //! Sends an internal message to reset the vehicle's occupant visibility
   //! to match the cached value from before player engagement
   virtual void restoreOccupantState();
 
   //! \brief Flag indicating if player is directly controlling the vehicle (not embarked)
   bool myPlayerIsImplicitDriver;
 
   //! \brief Flag indicating if the initial occupant state has been cached
   bool myCachedOccupantState;
 
   //! \brief The initial value of the HideOccupants attribute
   bool myInitialHideOccupantsState;
 
   //! \brief Pointer to the observer being used by this component
   makVrv::DtObserver* myObserver;
};
} // namespace makVre