lightStateController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file lightStateController.h
//! \ingroup vreVrfmodel
//! \brief Controller for managing platform light states
//!
//! This file defines the DtLightStateController class which manages the state of
//! platform lights such as headlights and brake lights based on input ports for
//! throttle, braking, and explicit light state controls.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include <vrfobjcore/controllerComponent.h>
 
//! Platform facades provide an API specific to particular platform types
//! Light state functionality is available for platforms but not for other entity types like tactical graphics
#include <vrfobjcore/platformLocalObjectFacade.h>
 
class DtBooleanInputPort;
class DtStringInputPort;
class DtAnalogInputPort;
class DtInputPortGroup;
 
namespace makVre
{
 
//! \brief Type identifier for the light state controller component
const char DtLightStateControllerType[] = "light-state-controller";
 
//! \brief Controller for managing platform light states
//!
//! DtLightStateController monitors inputs related to vehicle operation such as
//! throttle and brake application, as well as explicit light control inputs,
//! and uses these to manage the state of a platform's lights (headlights, brake
//! lights, etc.). The controller provides a centralized way to control light
//! states based on platform operation.
class VREVRFMODEL_DLL DtLightStateController : public DtControllerComponent
{
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 light state controller component with the specified parameters.
   DtLightStateController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the light state controller component.
   virtual ~DtLightStateController() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtLightStateControllerType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   //! \brief Creates port groups for this component
   //! \return True if port groups were created successfully, false otherwise
   //!
   //! Creates and initializes the input port groups used by this controller
   //! for light state control.
   virtual bool createPortGroups() override;
 
   //! \brief Creates input and output ports for this component
   //! \return True if ports were created successfully, false otherwise
   //!
   //! Creates and initializes all input ports used by this controller
   //! for light state control, including ports for headlights, throttle,
   //! and brake inputs.
   virtual bool createPorts() override;
 
   //! \brief Factory method to create a new instance of this component
   //! \param name The name for the new component
   //! \param owner The local object that will own this component
   //! \param simManager The simulation services manager
   //! \param desc Optional component descriptor
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //! \return Pointer to the newly created component
   //!
   //! Static factory method used by the component creation system to instantiate
   //! new instances of this component type.
   static DtSimComponent* creator(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtLightStateController();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtLightStateController(const DtLightStateController& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   DtLightStateController& operator=(const DtLightStateController& orig);
 
protected:
   //! \brief Updates the light state each simulation frame
   //!
   //! Processes light state control inputs and updates the platform's
   //! light states based on current headlight switch, throttle, and brake inputs.
   virtual void tick() override;
 
   //! \brief Input port group for light state controls
   //!
   //! Contains all input ports related to light state control.
   DtInputPortGroup* myStatePortGroup;
 
   //! \brief Input port for headlight control
   //!
   //! When true, indicates that headlights should be turned on.
   DtBooleanInputPort* myHeadlightPort;
 
   //! \brief Input port for throttle state
   //!
   //! Analog input representing the current throttle position,
   //! with 0.0 being idle and 1.0 being full throttle.
   DtAnalogInputPort* myThrottlePort;
 
   //! \brief Input port for brake state
   //!
   //! Analog input representing the current brake application,
   //! with 0.0 being no braking and 1.0 being full braking.
   DtAnalogInputPort* myBrakePort;
 
   //! \brief Facade for platform local object access
   //!
   //! Provides simplified access to platform-specific functionality
   //! of the local object, including light state control.
   DtPlatformLocalObjectFacade myPlatformLocalObjectFacade;
};
 
} // namespace makVre