RoverInterface.h

#pragma once
 
#include "HAL/Platform.h"
#include "Math/MathFwd.h"
class ARoverVehiclePawn;
 
UENUM(BlueprintType)
/* An enum which is used to select which interface to instantiate for the given RoverVehiclePawn instance.
 *
 * This is needed because otherwise interfaces could either not be selected, defeating the point, or you
 * would need to implement a bunch of factories and convert the interfaces into UObjects to allow Unreal
 * to directly instantiate them.
 */
enum class ERoverInterfaceSubclasses : uint8
{
  Talos2025
};
 
/**
 * @brief Interface which represents the logic expected to change depending on rover version.
 *
 * This was seperated from the main RoverVehiclePawn logic so multiple versions of rover could function in-sim at the same time.
 * Implementations should:
 * - Be entirely stateless and must gather and process the needed data for the requested operation themselves.
 * - Be friended to RoverVehiclePawn to allow access to protected pointer references.
 * - Have at minimum one manual drive and one RoveComm drive control modes
 */
class IRoverInterface
{
public:
  virtual ~IRoverInterface() = default;
  virtual constexpr const uint8 GetNumControlStates() = 0;
  // Is this control mode a 'DirectDrive' mode (i.e. Throttles are controlled directly via some input device)
  virtual constexpr const bool IsDirectDriveControlMode(uint8 state) = 0;
  // Is this control mode a 'RotationDrive' mode (i.e. RotationDelta downticking occurs for this mode)
  virtual constexpr const bool IsRotationDriveControlMode(uint8 state) = 0;
  // Is this control mode a 'RoveCommDrive' mode (i.e. Input for this mode comes via RoveComm)
  virtual constexpr const bool IsRoveCommDriveControlMode(uint8 state) = 0;
  // Is this control mode a 'RoverDrive' mode (i.e. Moves/controls the rover as opposed to attachments/other systems)
  virtual constexpr const bool IsRoverDriveControlMode(uint8 state) = 0;
  // Is this camera mode an 'orbit' camera? (i.e. The camera rotates around a target on a springarm)
  virtual constexpr const bool IsOrbitCameraMode(uint8 state) = 0;
  // Is this camera mode a 'locked' camera? (i.e. The camera cannot move or rotate at all)
  virtual constexpr const bool IsLockedCameraMode(uint8 state) = 0;
  // Is this camera mode a 'fixed' camera (i.e. The camera can rotate on at least one of its axes but not move)
  virtual constexpr const bool IsFixedCameraMode(uint8 state) = 0;
  // Is this camera mode a 'free' camera (i.e. The camera can move and rotate fully independently of the rover)
  virtual constexpr const bool IsFreeCameraMode(uint8 state) = 0;
  // Is this camera mode 'rotatable' (i.e. either orbit, fixed, or free)
  virtual constexpr const bool IsRotatableCameraMode(uint8 state) = 0;
  virtual constexpr const FVector GetColorForControlState(uint8 state) = 0;
 
  virtual void InitalizeStates(ARoverVehiclePawn* rover) = 0;
  virtual void HandleAttachmentState(ARoverVehiclePawn* rover) = 0;
  virtual void HandleCameraState(ARoverVehiclePawn* rover) = 0;
  virtual void CameraCycleCallback(ARoverVehiclePawn* rover, const bool forwards) = 0;
  virtual void HandleControlState(ARoverVehiclePawn* rover) = 0;
  virtual void ControlModeCycleCallback(ARoverVehiclePawn* rover, const bool forwards) = 0;
  virtual const bool ControlModeSetCallback(ARoverVehiclePawn* rover, short num) = 0;
 
  virtual void LeftThrottleCallback(ARoverVehiclePawn* rover, const float value) = 0;
  virtual void RightThrottleCallback(ARoverVehiclePawn* rover, const float value) = 0;
  virtual void TranslationCallback(ARoverVehiclePawn* rover, const float value) = 0;
  virtual void RotationCallback(ARoverVehiclePawn* rover, const float value) = 0;
  virtual void ZoomCallback(ARoverVehiclePawn* rover, const float value) = 0;
};