artPartActuator.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file artPartActuator.h
//! \ingroup vreVrfmodel
//! \brief Stabilized articulated part actuator component for VR Engage
//!
//! This file defines the DtVreStabilizedArtPartActuator class which provides control
//! for rotating articulated parts with stabilization capabilities.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include "vreVrfmodel/vreSimComponent.h"
 
#include <vrfobjcore/actuatorComponent.h>
 
#include <vreMessageManager/vreMessage.h>
 
class DtString;
class DtSimulationServices;
 
class DtVreStabilizedArtPartActuatorDescriptor;
class DtConstrainedAnalogInputPort;
class DtBooleanInputPort;
 
//! \brief DtTurretActuatorComponent provides a simple model of a
//! rotating turret that knows how to drive the articulating parts objects of
//! the local state repository.
//!
//! End User Description: The turret actuator updates the articulated part
//! specified in its component descriptor, based on slew data it receives.  It
//! expects an input (via a mySlewPort) of a slew amount between -1. and +1.
//!
//! Developer Description: The tick() function first checks to see if dT is
//! 0.0. If it is, it just returns. Otherwise, it looks up the
//! DtArticulatedPartStateRepository object kept by the entity to maintain state for
//! the turret using DtAttachmentManager::findPartByType with the turret art
//! part type from the process state repository as the argument.
//! The current angle of the turret (with respect to whatever is it attached
//! to) is retrieved from the DtArticulatedPartStateRepository which represents the
//! turret by going through the kinematic state to get the "psi" component of
//! the parent orientation.
//! The slewRate to use is calculated using:
//! the value on the slew port * myMaxSlewRate
//! The new turret angle is calculated as:
//! the current angle + (slew rate * dT)
//! The angle is then constrained to be between 0.0 and 2 * PI using the
//! VR-Link utility function DtModPerLo(). The new angle is then stored in the
//! kinematic state of the rotating body.
//!
//! Uses Descriptor Type: DtTurretComponentDescriptor
 
namespace makVre
{
const char DtVreStabilizedArtPartActuatorType[] = "vre-stabilized-art-part-actuator";
 
class VREVRFMODEL_DLL DtVreStabilizedArtPartActuator : public DtVreSimComponent<DtActuatorComponent>
{
public:
   //! \copydoc DtSimComponent(const DtString&,DtLocalObject*,DtSimulationServices*,
   //! DtComponentDescriptor*,DtReaderWriterRegistry* parentRegistry)
   DtVreStabilizedArtPartActuator(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! destructor
   virtual ~DtVreStabilizedArtPartActuator() override;
 
   //! \copydoc DtSimComponent::type()
   //! \return DtTurretActuatorType
   virtual const char* type() const override;
 
   virtual bool init() override;
 
   //! Calls lookupAndCacheProcessSR() and initProcessSR()
   virtual bool postAddComponentsInit() override;
 
   //! Calculate new kinematic state.
   virtual void tick() override;
 
   //! \copydoc DtSimComponent(const DtString&,DtLocalObject*,DtSimulationServices*,
   //! DtComponentDescriptor*,DtReaderWriterRegistry* parentRegistry)
   //! \return New instance of this class.
   static DtSimComponent* creator(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
protected:
   //! default constructor; not implemented
   DtVreStabilizedArtPartActuator();
 
   //! copy constructor; not implemented
   DtVreStabilizedArtPartActuator(const DtVreStabilizedArtPartActuator& orig);
 
   //! assignment operator; not implemented
   const DtVreStabilizedArtPartActuator& operator=(const DtVreStabilizedArtPartActuator& orig);
 
   //! Creates the slew port.
   virtual bool createPorts() override;
 
   DtVector getLocalRotationAxis(const DtDcm& orientation);
   double calculateSlewToTarget(const DtVector& target);
   bool checkStabilizeState();
   void setCueToCurrent();
   double getSlewPortInput();
   double realizeSlew(double& slewRate);
   DtDcm axisOrientation() const;
 
   // Handler for SlewToCue message.
   virtual DtVreMessageResult handleSlewToCue(DtVreMessage* msg);
 
   //! \name Ports and Port Groups
   //! @{
 
   //! Input Port Name: slew\n
   //! Input Port Description: -1.0 indicates maximum left slew, 1.0 indicates
   //! maximum right slew\n
   //! Input Port Range: -1. to 1.\n
   //! Input Port Default Value: \n
   //! Input Group Parent:
   DtConstrainedAnalogInputPort* mySlewPort;
 
   //! Input Port Name: stabilize\n
   //! Input Port Description: Set stabilization on or off for this actuator.\n
   //! Input Port Range: \n
   //! Input Group Parent: \n
   DtBooleanInputPort* myStabilizePort;
 
   //! @}
 
   const DtVreStabilizedArtPartActuatorDescriptor* myArtPartActuatorDescriptor;
 
   DtArtPartType myPartType;
 
   makVrf::DtArticulatedPartStateRepository* myPart;
 
   //! Cache for the condition for 360 rotation, which is
   //! hasFixedAzimuth = false and leftLimit = rightLimit
   //! (all info from turretComponentDescriptor)
   bool myRotation360;
 
   //! Local copies of the parameters in the turret descriptor,
   //! conditioned to be between 0 and 2pi.
   DtReal myLowerLimit;
   DtReal myUpperLimit;
 
   bool myStabilizeButtonDown;
   bool myStabilizationOn;
 
   DtVector myCueVector;
   bool mySlewToCueOverrideActive;
 
   //! When switching weapon systems, we can't rely on the port to determine if there's been
   //! new data sent. Therefore, if we switched away from this weapon while giving turret
   //! input, we need to cache that last input value so we can test it against new inputs when
   //! we switch back.
   bool myRequireNewData;
   double myLastInput;
};
 
} // namespace makVre