vreSimComponent.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreSimComponent.h
//! \ingroup vreVrfmodel
//! \brief Base template class for VR-Engage simulation components
//!
//! This file defines the DtVreSimComponent template class which serves as the
//! base class for VR-Engage simulation components. It extends VR-Forces base
//! components with VR-Engage specific functionality such as player control detection
//! and entity system name retrieval.
 
#pragma once
 
#include "vreVrfmodel/export.h"
 
#pragma warning(push)
#pragma warning(disable : 4100) // unused parameter
#pragma warning(disable : 4244) // type conversion, possible loss of data
 
#include <vrfobjcore/vrfObjectStateRepository.h>
#include <vlutil/vlString.h>
 
#pragma warning(pop)
 
class DtSimulationServices;
class DtComponentDescriptor;
class DtReaderWriterRegistry;
 
namespace makVre
{
//! \brief Base template class for VR-Engage simulation components
//! \tparam ComponentBase The base component class to extend with VR-Engage functionality
//!
//! DtVreSimComponent is a template class that serves as the base for VR-Engage
//! simulation components. It extends VR-Forces base component classes with VR-Engage
//! specific functionality such as player control detection and entity system name
//! retrieval. All VR-Engage components should derive from this template class.
template <typename ComponentBase>
class VREVRFMODEL_DLL DtVreSimComponent : public ComponentBase
{
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 Component descriptor with configuration parameters
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //!
   //! Creates a new VR-Engage simulation component with the specified parameters.
   //! Forwards all parameters to the base component class constructor.
   DtVreSimComponent(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0)
      : ComponentBase(name, owner, simManager, desc, parentRegistry)
   {
   }
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the VR-Engage simulation component.
   //! Base component resources are cleaned up by the base class destructor.
   virtual ~DtVreSimComponent() {}
 
   //! \brief Checks if the entity is player controlled
   //! \param role Optional role name to check for (empty string to check for any role)
   //! \return True if the entity has the specified role or any role if no specific role is provided
   //!
   //! Determines whether the entity is under player control by checking for role assignments
   //! in the entity's extended data. If a specific role is provided, checks only for that role.
   //! If no role is specified, checks for any role assignment.
   //!
   //! In VR-Engage, player control is indicated by the presence of role assignments
   //! stored as extended data entries with keys beginning with "role-".
   bool isPlayerControlled(const std::string& role = "") const
   {
      if (!role.empty())
      {
         // return true if the specific role entry is not empty
         const makVrf::DtVrfStateComponent* component =
            this->entity()->getNextFrameStateComponent<makVrf::DtVrfStateComponent>();
         const DtVrfObjectStateRepository::ExtendedData& extendedDataMap = component->extendedData();
         std::string key = "role-" + role;
         DtVrfObjectStateRepository::ExtendedData::const_iterator valueIter = extendedDataMap.find(key.c_str());
         if (valueIter != extendedDataMap.end())
         {
            return true;
         }
      }
      else
      {
         // No specific role given, search map for any entries with a key starting with "role-"
         const DtVrfObjectStateRepository::ExtendedData& extendedDataMap =
            this->entity()->getNextFrameStateComponent<makVrf::DtVrfStateComponent>()->extendedData();
         DtVrfObjectStateRepository::ExtendedData::const_iterator iter = extendedDataMap.begin();
         DtVrfObjectStateRepository::ExtendedData::const_iterator end = extendedDataMap.end();
         for (; iter != end; ++iter)
         {
            // return true if we find any role entry that is not empty
            if (iter->first.findString("role-") == 0 && !iter->second.isEmpty())
            {
               return true;
            }
         }
      }
      return false;
   }
 
   //! \brief Gets the entity's top-level system name
   //! \return String containing the top-level system name from the entity definition
   //!
   //! Retrieves the name of the top-level system (direct child of base-system)
   //! defined in the entity file. This is extracted from the full parent system name
   //! by removing the "base-system." prefix and any suffixes after the first period.
   //!
   //! \note This implementation uses string manipulation since DtComponentSystem
   //! does not provide a direct accessor for the top-level system name.
   DtString entitySystemName() const
   {
      DtString name = this->parentSystem()->fullName();
      if (name.findString("base-system") == 0)
      {
         name.snipFront('.');
      }
      name.snipBackToFirst('.');
      return name;
   }
 
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtVreSimComponent();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreSimComponent(const DtVreSimComponent& other);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   DtVreSimComponent& operator=(const DtVreSimComponent& other);
};
} // namespace makVre