artPartUpdater.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file artPartUpdater.h
//! \brief Defines the DtArtPartUpdater component that monitors and reflects the state of articulated parts.
//!
//! This component monitors the state of articulated parts in the engaged entity and provides
//! boolean state attributes that can be used by other components to react to part states.
//!
//! \ingroup vreCommonComponents
 
#pragma once
 
#include "vreCommonComponents/export.h"
 
#include "vrePlayerStation/entityControlLogic.h"
 
namespace makVre
{
 
namespace ArtPartUpdaterConfig
{
//! \ingroup RoleConfigParams
//! \defgroup ArtPartUpdaterRoleParams Art Part Updater Role Parameters
//! \roleInherits{PlayerComponentRoleParams}
//! Configuration Options for art part updater role.
//! @{
 
//! \vreRoleParamRequired{artParts,table,artPartUpdater,{},Table of articulated part configurations defining which parts to monitor and their thresholds.}
constexpr const char* artParts = "artParts";
 
//! @}
} // namespace ArtPartUpdaterConfig
 
//! \brief Type identifier for DtArtPartUpdater component
constexpr const char* DtArtPartUpdaterType = "DtArtPartUpdater";
 
//! \brief Component for monitoring and reflecting the state of articulated parts
//!
//! The DtArtPartUpdater monitors specified articulated parts of the engaged entity.
//! For each configured part, it provides two state attributes:
//! - has[PartName]: Boolean indicating if the entity has the specified articulated part
//! - [partName]State: Boolean indicating if the part's parameter value meets a configured threshold
//!
//! This component is particularly useful for quickly determining states such as
//! whether doors are open/closed or other articulated parts are in specific positions.
//!
//! Example Lua configuration:
//! \code
//! ["artPartUpdater"] = {
//!    componentType = "DtArtPartUpdater";
//!    priority = 5;
//!    artParts = {
//!       {part = 3232, label = "slingLoadDoor", param = "theta", trueThreshold = 0};
//!       {part = 7648, label = "cargoDoor", param = "theta", trueThreshold = 0};
//!       {part = 7680, label = "slidingDoor", param = "y", trueThreshold = 0};
//!    };
//! };
//! \endcode
class VRECOMMONCOMPONENTS_DLL DtArtPartUpdater : public makVre::DtPlayerComponent
{
public:
   //! \brief Constructor for DtArtPartUpdater
   //!
   //! Initializes the component with the name "DtArtPartUpdater".
   DtArtPartUpdater();
 
   //! \brief Virtual destructor for DtArtPartUpdater
   virtual ~DtArtPartUpdater() override;
 
   //! \brief Initializes the component with configuration from Lua
   //!
   //! Processes the provided configuration to set up monitoring for specified
   //! articulated parts. Creates state attributes for each part and registers
   //! handlers for simulation state and menu action messages.
   //!
   //! \param player Pointer to the player station this component belongs to
   //! \param config Configuration table containing initialization parameters, especially the artParts table
   //! \return True if initialization succeeds, false otherwise
   virtual bool initialize(makVre::DtPlayerStation* player, makVre::DtInitTable& config) override;
 
   //! \brief Updates the component state (empty implementation)
   //!
   //! This method is called each frame, but currently has no implementation for this component.
   //!
   //! \param dt Delta time in seconds since the last tick
   virtual void tick(double dt) override;
 
protected:
   //! \brief Sets the has[PartName] attribute in the state repository
   //!
   //! Creates or updates a state attribute of the form "has[PartName]" with the provided boolean value.
   //! The first character of the part label is capitalized in the attribute name.
   //!
   //! \param partLabel The label of the articulated part
   //! \param value The boolean value to set for the attribute
   virtual void setHasPartAttribute(std::string partLabel, bool value);
 
   //! \brief Handles simulation state messages
   //!
   //! Processes simulation state messages to extract articulated part information and
   //! updates corresponding state attributes based on the configured mappings.
   //! For each configured part that exists, sets has[PartName]=true and updates
   //! [partName]State based on the comparison with the threshold value.
   //!
   //! \param msg The simulation state message to process
   //! \return HANDLED if the message was successfully processed
   virtual makVre::DtVreMessageResult handleSimState(makVre::DtVreMessage* msg);
 
   //! \brief Handles menu action messages
   //!
   //! Processes menu action messages specifically for the "cargoDoor" action.
   //! Based on the current cargoDoorState, sends appropriate entity task messages
   //! to open or close the cargo ramp.
   //!
   //! \param msg The menu action message to process
   //! \return HANDLED if the message was handled, IGNORED otherwise
   virtual DtVreMessageResult handleMenuMessage(makVre::DtVreMessage* msg);
 
   //! \brief Shuts down the component
   //!
   //! Removes the simulation state and menu action message handlers.
   virtual void shutdown() override;
 
   //! \brief Returns the component type identifier
   //! \return The component type string
   virtual const char* type() const override;
 
   //! \brief Structure defining parameters for monitoring an articulated part
   using partVars = struct
   {
      //! \brief Label for the articulated part used in attribute names
      std::string label;
 
      //! \brief Parameter to monitor for the articulated part (e.g., "x", "y", "z", "psi", "theta", "phi")
      std::string param;
 
      //! \brief Threshold value for the parameter that determines when the part's state is considered true
      int trueThreshold;
   };
 
   //! \brief Map of art part IDs to their monitoring parameters
   //!
   //! The map keys are DIS articulated part type enumeration values,
   //! and the values are partVars structures.
   std::map<int, partVars> myParts;
};
} // namespace makVre