IInputInterface.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Containers/Array.h"
#include "Math/Color.h"
#include "UObject/NameTypes.h"
 
 
// General identifiers for potential force feedback channels. These will be mapped according to the
// platform specific implementation.
// For example, Platform A only listens to the XXX_LARGE channels and ignores the rest, while Platform B could
// map the XXX_LARGE to the handle motors and XXX_SMALL to the trigger motors. And others can map LEFT_SMALL to
// its single motor.
enum class FForceFeedbackChannelType
{
    LEFT_LARGE,
    LEFT_SMALL,
    RIGHT_LARGE,
    RIGHT_SMALL
};
 
 
struct FForceFeedbackValues
{
    float LeftLarge;
    float LeftSmall;
    float RightLarge;
    float RightSmall;
 
    FForceFeedbackValues()
        : LeftLarge(0.f)
        , LeftSmall(0.f)
        , RightLarge(0.f)
        , RightSmall(0.f)
    { }
};
 
struct FHapticFeedbackBuffer
{
    const uint8* RawData;
    uint32 CurrentPtr;
    int BufferLength;
    int SamplesSent;
    bool bFinishedPlaying;
    int SamplingRate;
    float ScaleFactor;
    bool bUseStereo;
    uint32 CurrentSampleIndex[2];
 
    FHapticFeedbackBuffer()
        : CurrentPtr(0)
        , BufferLength(0)
        , SamplesSent(0)
        , bFinishedPlaying(false)
        , SamplingRate(0)
        , bUseStereo(false)
        , CurrentSampleIndex{}
    {
    }
 
    bool NeedsUpdate() const
    {
        return !bFinishedPlaying;
    }
};
 
struct FHapticFeedbackValues
{
    float Frequency;
    float Amplitude;
 
    FHapticFeedbackBuffer* HapticBuffer;
 
    FHapticFeedbackValues()
        : Frequency(0.f)
        , Amplitude(0.f)
        , HapticBuffer(NULL)
    {
    }
 
    FHapticFeedbackValues(const float InFrequency, const float InAmplitude)
    {
        // can't use FMath::Clamp here due to header files dependencies
        Frequency = (InFrequency < 0.f) ? 0.f : ((InFrequency > 1.f) ? 1.f : InFrequency);
        Amplitude = (InAmplitude < 0.f) ? 0.f : ((InAmplitude > 1.f) ? 1.f : InAmplitude);
        HapticBuffer = NULL;
    }
};
 
enum class EInputDeviceTriggerMask : uint8
{
    None        = 0x00,
    Left        = 0x01,
    Right       = 0x02,
    All         = Left | Right
};
ENUM_CLASS_FLAGS(EInputDeviceTriggerMask)
 
 
enum class EInputDeviceAnalogStickMask : uint8
{
    None = 0x00,
    Left = 0x01,
    Right = 0x02
};
ENUM_CLASS_FLAGS(EInputDeviceAnalogStickMask)
 
struct FInputDeviceProperty
{
    FInputDeviceProperty(FName InName)
        : Name(InName)
    {}
 
    FName Name;
};
 
struct FInputDeviceGyroAutoCalibrationProperty : public FInputDeviceProperty
{
    FInputDeviceGyroAutoCalibrationProperty()
        : FInputDeviceProperty(PropertyName())
    {}
 
    FInputDeviceGyroAutoCalibrationProperty(bool bInEnable)
        : FInputDeviceProperty(PropertyName())
        , bEnable(bInEnable)
    {}
 
    static FName PropertyName() { return FName("InputDeviceGyroAutoCalibration"); }
 
    bool bEnable = true;
};
 
struct FInputDeviceLightColorProperty : public FInputDeviceProperty
{
    FInputDeviceLightColorProperty()
        : FInputDeviceProperty(PropertyName())
    {}
 
    FInputDeviceLightColorProperty(bool bInEnable, FColor InColor)
        : FInputDeviceProperty(PropertyName())
        , bEnable(bInEnable)
        , Color(InColor)
    {}
 
    static FName PropertyName() { return FName("InputDeviceLightColor"); }
 
    bool bEnable = true;
    
    FColor Color = FColor::White;
}; 
 
struct FInputDeviceTriggerProperty : public FInputDeviceProperty
{
    FInputDeviceTriggerProperty(FName InName)
        : FInputDeviceProperty(InName)
    {}
 
    EInputDeviceTriggerMask AffectedTriggers = EInputDeviceTriggerMask::None;
};
 
struct FInputDeviceTriggerResetProperty : public FInputDeviceTriggerProperty
{
    FInputDeviceTriggerResetProperty()
        : FInputDeviceTriggerProperty(PropertyName())
    {
        AffectedTriggers = EInputDeviceTriggerMask::All;
    }
 
    static FName PropertyName() { return FName("InputDeviceTriggerResetProperty"); }
};
 
struct FInputDeviceTriggerFeedbackProperty : public FInputDeviceTriggerProperty
{
    FInputDeviceTriggerFeedbackProperty()
        : FInputDeviceTriggerProperty(PropertyName())
    {}
 
    static FName PropertyName() { return FName("InputDeviceTriggerFeedback"); }
 
    int32 Position = 0;
 
    int32 Strengh = 0;
};
 
struct FInputDeviceTriggerResistanceProperty : public FInputDeviceTriggerProperty
{
    FInputDeviceTriggerResistanceProperty()
        : FInputDeviceTriggerProperty(PropertyName())
    {}
 
    static FName PropertyName() { return FName("InputDeviceTriggerResistance"); }
 
    int32 StartPosition = 0;
 
    int32 StartStrengh = 0;
 
    int32 EndPosition = 0;
 
    int32 EndStrengh = 0;
};
 
struct FInputDeviceTriggerVibrationProperty : public FInputDeviceTriggerProperty
{
    FInputDeviceTriggerVibrationProperty()
        : FInputDeviceTriggerProperty(PropertyName())
    {}
 
    static FName PropertyName() { return FName("InputDeviceTriggerVibration"); }
 
    int32 TriggerPosition = 0;
 
    int32 VibrationFrequency = 0;
 
    int32 VibrationAmplitude = 0;
};
 
struct FInputDeviceAnalogStickProperty : public FInputDeviceProperty
{
    FInputDeviceAnalogStickProperty(FName InName)
        : FInputDeviceProperty(InName)
    {}
 
    FInputDeviceAnalogStickProperty(FName InName, EInputDeviceAnalogStickMask InAffectedStick)
        : FInputDeviceProperty(InName)
        , AffectedStick(InAffectedStick)
    {}
 
    EInputDeviceAnalogStickMask AffectedStick = EInputDeviceAnalogStickMask::None;
};
 
struct FInputDeviceAnalogStickDeadZoneProperty : public FInputDeviceAnalogStickProperty
{
    FInputDeviceAnalogStickDeadZoneProperty()
        : FInputDeviceAnalogStickProperty(PropertyName())
    {}
 
    FInputDeviceAnalogStickDeadZoneProperty(EInputDeviceAnalogStickMask InAffectedStick, float InDeadZone)
        : FInputDeviceAnalogStickProperty(PropertyName(), InAffectedStick)
        , DeadZone(InDeadZone)
    {}
 
    static FName PropertyName() { return FName("InputDeviceAnalogStickDeadZone"); }
 
    float DeadZone = 0;
};
 
struct FInputDeviceTriggerDynamicReleaseDeadZoneProperty : public FInputDeviceTriggerProperty
{
    FInputDeviceTriggerDynamicReleaseDeadZoneProperty()
        : FInputDeviceTriggerProperty(PropertyName())
    {}
 
    FInputDeviceTriggerDynamicReleaseDeadZoneProperty(EInputDeviceTriggerMask InAffectedTriggers, float InDeadZone)
        : FInputDeviceTriggerProperty(PropertyName())
        , DeadZone(InDeadZone)
    {
        AffectedTriggers = InAffectedTriggers;
    }
 
    static FName PropertyName() { return FName("InputDeviceTriggerDynamicReleaseDeadZone"); }
 
    float DeadZone = 1.0f;
};
 
class IInputInterface
{
public:
 
    virtual ~IInputInterface() { };
 
    virtual void SetForceFeedbackChannelValue(int32 ControllerId, FForceFeedbackChannelType ChannelType, float Value) = 0;
 
    virtual void SetForceFeedbackChannelValues(int32 ControllerId, const FForceFeedbackValues &Values) = 0;
 
    virtual void SetHapticFeedbackValues(int32 ControllerId, int32 Hand, const FHapticFeedbackValues& Values) {}
 
    virtual void SetDeviceProperty(int32 ControllerId, const FInputDeviceProperty* Property) {};
 
    /*
     * Sets the light color for the given controller.  Ignored if controller does not support a color.
     */
    virtual void SetLightColor(int32 ControllerId, FColor Color) = 0;
    
    /*
     * Resets the light color for the given controller.  Ignored if controller does not support a color.
     */
    virtual void ResetLightColor(int32 ControllerId) = 0;
};