deployableObjectsSimLogic.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2024 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//\file deployableObjectsLogic.h
//\brief DtDeployableObjectsLogic;
// Manage deployment and retrieval of drone and deployable launcher
// and remote view inset drone and remote sensor entities.
 
#pragma once
 
#include "vreCommonComponents/export.h"
 
#include "vreCommonComponents/stateDefines.h"
#include "vrePlayerStation/entityControlLogic.h"
#include "vreMessageManager/vreMessage.h"
#include "vreMessages/simulationState.h"
 
#include <vrvCore/DtUniqueID.h>
 
#include <matrix/vlVector.h>
#include <vlpi/appearance.h>
 
#include <vector>
#include "matrix/vlVector.inl"       // for DtVector64::DtVector64, DtVector64::operator=
#include "vlpi/entityIdentifier.h"   // for DtEntityIdentifier
#include "vlpi/entityIdentifier.inl" // for DtEntityIdentifier::DtEntityIdentifier, DtEntityIdentifier::operator=
#include "xstring"                   // for string, basic_string
 
namespace makVre
{
 
namespace DeployableObjectsSimLogicConfig
{
//! \ingroup RoleConfigParams
//! \defgroup DeployableObjectsSimLogicRoleParams Deployable Objects Simulation Logic Role Parameters
//! \roleInherits{EntityControlLogicRoleParams}
//! Configuration Options for deployable objects simulation logic role including drones, launchers, and remote viewing.
//! @{
 
//! \vreRoleParam{droneBatteryWarnings,table,{},deployableObjectsSimLogic,Configuration table for drone battery warning thresholds and messages.}
constexpr const char* droneBatteryWarnings = "droneBatteryWarnings";
 
//! \vreRoleParam{droneOverlaySections,vector<string>,{},deployableObjectsSimLogic,Vector of overlay section names to display when using a drone sensor view.}
constexpr const char* droneOverlaySections = "droneOverlaySections";
 
//! \vreRoleParam{droneSensorModes,vector<string>|table,{},deployableObjectsSimLogic,Available sensor modes for drone cameras or nested configuration for sensor mode mappings.}
constexpr const char* droneSensorModes = "droneSensorModes";
 
//! \vreRoleParam{droneStatusUpdateDisplayTime,double,2.0,deployableObjectsSimLogic,Duration in seconds to display drone status update notifications.}
constexpr const char* droneStatusUpdateDisplayTime = "droneStatusUpdateDisplayTime";
 
//! \vreRoleParam{lockTargetHoldTime,double,varies,deployableObjectsSimLogic,Time in seconds to maintain target lock for weapon systems.}
constexpr const char* lockTargetHoldTime = "lockTargetHoldTime";
 
//! \vreRoleParamRequired{maxDGain,double,deployableObjectsSimLogic,1.0,Maximum derivative gain value for PID control systems.}
constexpr const char* maxDGain = "maxDGain";
 
//! \vreRoleParamRequired{maxFGain,double,deployableObjectsSimLogic,1.0,Maximum feedforward gain value for control systems.}
constexpr const char* maxFGain = "maxFGain";
 
//! \vreRoleParamRequired{maxIGain,double,deployableObjectsSimLogic,1.0,Maximum integral gain value for PID control systems.}
constexpr const char* maxIGain = "maxIGain";
 
//! \vreRoleParamRequired{maxPGain,double,deployableObjectsSimLogic,1.0,Maximum proportional gain value for PID control systems.}
constexpr const char* maxPGain = "maxPGain";
 
//! \vreRoleParam{remoteViewer,table,{},deployableObjectsSimLogic,Configuration table for remote viewer including channel name\, sensor mode\, zoom level\, and viewport settings.}
constexpr const char* remoteViewer = "remoteViewer";
 
//! \vreRoleParam{targetLockFadeRate,double,varies,deployableObjectsSimLogic,Rate at which target lock weight fades over time.}
constexpr const char* targetLockFadeRate = "targetLockFadeRate";
 
//! \vreRoleParam{thirdPersonOnUseDrone,bool,true,deployableObjectsSimLogic,Whether to switch to third-person view when using a drone.}
constexpr const char* thirdPersonOnUseDrone = "thirdPersonOnUseDrone";
 
//! \vreRoleParam{timeOnTargetForLock,double,varies,deployableObjectsSimLogic,Time in seconds required on target to achieve weapon lock.}
constexpr const char* timeOnTargetForLock = "timeOnTargetForLock";
 
//! \vreRoleParam{roleHasDeployables,bool,true,deployableObjectsSimLogic,Whether this role has deployable objects (if not, this could be a missile launcher role, for example.}
constexpr const char* roleHasDeployables = "roleHasDeployables";
 
//! \vreRoleParam{lookAtDroneOnUse,bool,true,deployableObjectsSimLogic,Whether the ownship should look at the drone when it is used.}
constexpr const char* lookAtDroneOnUse = "lookAtDroneOnUse";
 
//! @}
} // namespace DeployableObjectsSimLogicConfig
 
} // namespace makVre
 
 
namespace makVrv
{
class DtChannel;
class DtChannelManager;
} // namespace makVrv
 
 
namespace makVre
{
// class DtHumanEventProcessor;
// class DtHumanJoystickControl;
class EntityRealizedMessage;
class DtDeployableObjectsInputLogic;
class DtCreateNewEntityEventProcessor;
 
//! \brief Type identifier for DtDeployableObjectsSimLogic component
constexpr const char* DtDeployableObjectsSimLogicType = "DtDeployableObjectsSimLogic";
 
class VRECOMMONCOMPONENTS_DLL DtDeployableObjectsSimLogic : public DtEntityControlLogic
{
public:
   DtDeployableObjectsSimLogic();
   virtual ~DtDeployableObjectsSimLogic() override;
 
   virtual bool initialize(DtPlayerStation* player, DtInitTable& config) override;
   virtual bool postInitialize() override;
 
   virtual void tick(double dt) override;
   virtual void shutdown() override;
 
   //! \brief Returns the component type identifier
   //! \return The component type string
   virtual const char* type() const override;
 
   virtual void fireMissile(const std::string& rangeId = "");
 
   virtual void toggleMissileLauncher();
   virtual void useLauncher(const DtEntityIdentifier& id);
   virtual void useDrone(const DtEntityIdentifier& id = DtEntityIdentifier::nullId(), const std::string& marking = "");
   virtual void exitLauncher();
   virtual void stopUsingDrone();
 
   // If using a drone, this will set its "AutopilotMode" extended data.
   virtual void setDroneAutopilotMode(const std::string& mode);
 
   // Toggle the drone's autopilot mode between manual and task-based movement.
   virtual void toggleDroneAutopilotMode();
 
   virtual void setIndirectFireCoordinate(const std::string& coordinate);
   virtual void clearIndirectTarget();
 
   virtual void deployEmbeddedEntity(const std::string& embeddedEntityName);
   virtual void recoverEmbeddedEntity(const std::string& embeddedEntityName);
 
   virtual void toggleRemoteViewViewport(double val);
   virtual void setRemoteViewZoomLevel(double val);
   virtual std::string scopeChannelName() const;
 
   virtual bool operatingDrone();
   virtual void setFocusOnEntity(bool val);
   virtual void toggleFocusOnEntity();
   virtual void setForwardControls(bool val);
   virtual void toggleForwardControls();
   virtual void landDrone();
   virtual void returnToHome();
   virtual void toggleDroneChannelVisibility(bool visible);
 
   virtual void firstStageTrigger(double val);
 
   // Toggle current "attackMode" extended state data, representing
   // current attack mode of the launcher, top attack ("top-attack") or direct attack ("direct-attack").
   virtual void toggleMissileAttackMode(double val);
 
   virtual void sendJoystickCommand(const DtEntityIdentifier& id,
      const std::string& functionGroup,
      const std::string& function,
      double val,
      bool repeat = false);
 
   virtual void onDamageStateChanged(DtDamageState val);
 
   virtual DtEntityIdentifier launcherId();
 
   // Open/close remote view inset for sensor gimbal on given entity
   virtual void openRemoteSensorView(const DtEntityIdentifier& viewEntity);
   virtual void closeRemoteSensorView();
 
   struct DeployableObject
   {
      SimulationStateMessage::EmbeddedEntity myState;
      bool myInUse;
      bool myDestroyed;
 
      bool operator==(const DeployableObject& other) const
      {
         return myState == other.myState && myInUse == other.myInUse && myDestroyed == other.myDestroyed;
      }
   };
 
   // Map of deployable object label ("spark", "javelin", for example) to current state of the deployed object.
   using DeployableObjectStateMap = std::map<std::string, DeployableObject>;
 
protected:
   // If incoming message is for entering the menu state, set myShowOverlays to false.
   // This will hide overlays while we're in the menu state.
   virtual makVre::DtVreMessageResult handleEnterPlayerState(makVre::DtVreMessage* msg);
 
   // If incoming message is for exiting the menu state, set showOverlays to true.
   // This show overlays while in the running state.
   virtual makVre::DtVreMessageResult handleExitPlayerState(makVre::DtVreMessage* msg);
 
   bool scopeExists(DtEntityIdentifier& ownshipId, std::string& channelName);
 
   bool isAirborne() const;
   bool hasLauncher() const;
   bool isAimingLauncher() const;
 
   virtual makVre::DtVreMessageResult handleSimState(makVre::DtVreMessage* msg) override;
   virtual makVre::DtVreMessageResult handleEntityRealized(makVre::DtVreMessage* msg);
   virtual makVre::DtVreMessageResult handleEntityRemoved(makVre::DtVreMessage* msg);
   virtual makVre::DtVreMessageResult handleMenuActionMessage(makVre::DtVreMessage* msg);
   virtual makVre::DtVreMessageResult handleResourceUpdate(makVre::DtVreMessage* msg);
   virtual makVre::DtVreMessageResult handleFireInteraction(makVre::DtVreMessage* msg);
 
   virtual void updateOwnshipFromSimState(SimulationStateMessage* msg);
   virtual void updateEmbeddedEntityFromSimState(SimulationStateMessage* msg);
 
   virtual void checkForDroneBatteryWarning(float amount);
 
   virtual void processLauncherRemoved();
   virtual void processMissileRemoved();
   virtual void processMissileRealized(const DtEntityIdentifier& munitionId);
   virtual void updateLauncherFocus(double dt);
   virtual void enableLauncher(LauncherType launcherType = SHOULDER_MOUNTED);
   virtual void disableLauncher();
 
   virtual void updateSensor();
 
   virtual void nextSensor(double val);
 
   void onForwardControlsChanged(bool);
 
   // Blank the drone display, send a drone destroyed notification, disable drone controls
   virtual void setDroneDestroyed();
 
   virtual DtEntityIdentifier missileId();
 
   virtual void onSceneClicked(makVrv::DtUniqueID, const DtVector& location, double altAboveGround);
 
   struct ChannelViewport
   {
      int left;
      int right;
      int bottom;
      int top;
      bool showDroneFrame;
      bool showDroneHUDElements;
      bool showHumanOverlay;
   };
 
   DtEntityIdentifier myRemoteViewEntityId;
 
   std::string myRemoteViewChannelName;
   std::string myRemoteViewSensorMode;
   std::vector<ChannelViewport> myViewportConfigurations;
   bool myRemoteViewAttachToMunition;
   double myRemoteViewResetTime;
   double myRemoteViewZoomLevel;
   bool myThirdPersonOnUseDrone;
   ObserverAttachMode myCachedAttachMode;
 
   std::string myTargetName;
   std::string myMissileName;
   DtVector myPreviousRemoteViewTarget;
 
   DtEntityIdentifier myMissileId;
   DtEntityIdentifier myMissileToAttachTo;
 
   float myMaxPGain;
   float myMaxIGain;
   float myMaxDGain;
   float myMaxFGain;
 
   float myPGain;
   float myIGain;
   float myDGain;
   float myFGain;
 
   bool myShowPidMenu;
 
   // Map of battery amount to warning already displayed.
   std::map<int, bool> myDroneBatteryWarnings;
 
   // Duration in seconds for drone status update notifications.
   double myDroneStatusUpdateDisplayTime;
 
   // Target seeker
   std::map<makVrv::DtElementID, double> myPotentialTargetsWeightMap;
   double myTargetHoldWeight;
   double myTargetLockWeight;
   double myTargetWeightFadeRate;
 
   DtDeployableObjectsInputLogic* myInputLogic;
 
   DtCreateNewEntityEventProcessor* myEventProcessor;
 
   SensorViews myLastSensorViewMode;
   std::map<enum SensorViews, std::string> mySensorModes;
 
   bool myLookAtDroneOnUse;
};
} // namespace makVre