576 lines
22 KiB
C++
576 lines
22 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "Math/MathFwd.h"
|
|
#include "CoreTypes.h"
|
|
#include "Containers/Map.h"
|
|
#include "Misc/CoreMiscDefines.h" // For FInputDeviceId/FPlatformUserId
|
|
#include "GenericPlatform/GenericApplicationMessageHandler.h"
|
|
|
|
#if GAME_INPUT_SUPPORT
|
|
THIRD_PARTY_INCLUDES_START
|
|
#include "Microsoft/AllowMicrosoftPlatformTypes.h"
|
|
#include <GameInput.h>
|
|
#include "Microsoft/HideMicrosoftPlatformTypes.h"
|
|
THIRD_PARTY_INCLUDES_END
|
|
#include "Microsoft/COMPointer.h"
|
|
#endif // GAME_INPUT_SUPPORT
|
|
|
|
#if GAME_INPUT_SUPPORT
|
|
|
|
/**
|
|
* A Game Input Device Processor is used to determine the state of a device
|
|
* each frame and send messages to the given Message Handler when we want to.
|
|
* Each processor represents a single "kind" of Game Input device.
|
|
*
|
|
* They are created by the owning GameInput Device Container (GameInputDeviceContainer.h)
|
|
* and polled each frame when possible. Each Human Interface Device can be made up of multiple
|
|
* Game Input Kinds, so a single device container may have multiple different processors associated with it.
|
|
*/
|
|
class IGameInputDeviceProcessor
|
|
{
|
|
public:
|
|
GAMEINPUTBASE_API IGameInputDeviceProcessor();
|
|
|
|
virtual ~IGameInputDeviceProcessor() = default;
|
|
|
|
struct FGameInputEventParams
|
|
{
|
|
/** The current reading for this input event */
|
|
IGameInputReading* Reading = nullptr;
|
|
|
|
/** The previous reading from the last frame. */
|
|
IGameInputReading* PreviousReading = nullptr;
|
|
|
|
/** Device associated with this reading */
|
|
IGameInputDevice* Device = nullptr;
|
|
|
|
/** The message handler to use to send any input events */
|
|
TSharedPtr<FGenericApplicationMessageHandler> MessageHandler;
|
|
|
|
/** The platform user that is associated with the input device that triggered this event */
|
|
FPlatformUserId PlatformUserId = PLATFORMUSERID_NONE;
|
|
|
|
/** The Input device ID of the device that triggered this event. */
|
|
FInputDeviceId InputDeviceId = INPUTDEVICEID_NONE;
|
|
|
|
/** Gets the Input Device Info for this GameInput Device if it is valid. Can be null. */
|
|
GAMEINPUTBASE_API const GameInputDeviceInfo* GetDeviceInfo() const;
|
|
};
|
|
|
|
/**
|
|
* Process any input events from the given reading and send events to the message handler
|
|
* using the given Platform User and Input Device Id's.
|
|
*
|
|
* This can be called multiple times per frame, like if we are running at a lower FPS.
|
|
* This is because GameInput may accumulate multiple readings to use by the time the game thread gets here.
|
|
*
|
|
* If you have inputs that you only want to process once per frame, then use PostProcessInput instead.
|
|
*
|
|
* @return True if any input events have been processed, false if nothing happened
|
|
*/
|
|
virtual bool ProcessInput(const FGameInputEventParams& Params) = 0;
|
|
|
|
/**
|
|
* Called after all current Game Input readings have been processed
|
|
* this frame and there are no more readings for a device (GetNextReading returns GAMEINPUT_E_READING_NOT_FOUND).
|
|
* This is called regardless of if an accompanying ProcessInput call has happened.
|
|
*
|
|
* This function is useful for dealing with multiple readings in a single frame for analog devices.
|
|
* It is recommended that processors override this function and only process analog input events here at
|
|
* the end of the frame, once, instead of multiple times in ProcessInput. That is because at lower frame rates
|
|
* or hitches you will end up with more then one GameInput reading in the stack that we need to process. If you were to
|
|
* process all of those analog inputs in a single frame, the values would accumulate to above or below +-1.0,
|
|
* which could have unexpected behavior in Slate.
|
|
*
|
|
* @param Params Game Input event params sent from the owning FGameInputDeviceContainer.
|
|
* Params.Reading should always be null here, as there is no current reading.
|
|
* Params.PreviousReading will contain the most recent Game Input reading from the input stack.
|
|
*
|
|
* @return True if any input events have been processed, false if nothing happened
|
|
*/
|
|
GAMEINPUTBASE_API virtual bool PostProcessInput(const FGameInputEventParams& Params);
|
|
|
|
/**
|
|
* Clear any input state related to this processor, typically by sending events to the
|
|
* message handler that each FKey related to this processor now has a value of 0.
|
|
*/
|
|
virtual void ClearState(const FGameInputEventParams& Params) = 0;
|
|
|
|
/*
|
|
* Returns the kind of reading that this processor supports. If the current GameInput reading
|
|
* is not included in this bitmask, then this processor will not not have it's "ProcessInput"
|
|
* function called.
|
|
*
|
|
* @see FGameInputDeviceContainer::ProcessInput
|
|
*/
|
|
virtual GameInputKind GetSupportedReadingKind() const = 0;
|
|
|
|
protected:
|
|
|
|
/**
|
|
* Returns the string hardware device identifier for the given input event params that can be used
|
|
* to create an FInputDeviceScope
|
|
*/
|
|
GAMEINPUTBASE_API const FString& GetHardwareDeviceIdentifierName(const IGameInputDeviceProcessor::FGameInputEventParams& Params) const;
|
|
|
|
/** A general use function to call the message handler and tell it about a controller analog key being used */
|
|
GAMEINPUTBASE_API void OnControllerAnalog(const FGameInputEventParams& Params, const FName& GamePadKey, float NewAxisValueNormalized, float OldAxisValueNormalized, float DeadZone, const bool bSetDeviceScope = true);
|
|
|
|
/**
|
|
* Helper function for processing the button states of Game input.
|
|
*
|
|
* @param CurrentButtonHeldMask The current state of the button mask to evaluate
|
|
* @param PreviousButtonMask The previous state of the button mask. This value will be modified to store the current button mask after evaluation
|
|
* @param RepeatTime A map of the button index to a time that it was last active, used to determine if the key meets the qualifications for a repeat event
|
|
* @param UnrealButtonNameMap A map of Unreal Engine Gamepad key names to their uint32 mapping from Game Input.
|
|
* @param SupportedButtonCount The maximum number of buttons we can process
|
|
*/
|
|
GAMEINPUTBASE_API void EvaluateButtonStates(
|
|
const FGameInputEventParams& Params,
|
|
const uint32 CurrentButtonHeldMask,
|
|
uint32& PreviousButtonMask,
|
|
double* RepeatTime,
|
|
const TMap<uint32, FGamepadKeyNames::Type>& UnrealButtonNameMap,
|
|
const uint32 SupportedButtonCount);
|
|
|
|
/**
|
|
* Helper function to processing the state of a Switch position (aka a DPad, like left/right/up/down)
|
|
*
|
|
* @param Params The GameInput event params
|
|
* @param CurrentPosition The current position of the switch
|
|
* @param PreviousPosition The previous position of the switch. This will be set to the value of the current switch at the end of this function
|
|
* @param RepeatTimes Array of doubles that represent the time at which a switch was last pressed that we can use to check for when to send repeat events
|
|
*/
|
|
GAMEINPUTBASE_API void EvaluateSwitchState(
|
|
const FGameInputEventParams& Params,
|
|
GameInputSwitchPosition CurrentPosition,
|
|
GameInputSwitchPosition& PreviousPosition,
|
|
TArray<double>& RepeatTimes);
|
|
|
|
/** Delay before sending a repeat message after a button was first pressed */
|
|
float InitialButtonRepeatDelay;
|
|
|
|
/** Delay before sending a repeat message after a button has been pressed for a while */
|
|
float ButtonRepeatDelay;
|
|
};
|
|
|
|
/**
|
|
* Processor for Gamepad Inputs
|
|
*/
|
|
class FGameInputGamepadDeviceProcessor : public IGameInputDeviceProcessor
|
|
{
|
|
protected:
|
|
GAMEINPUTBASE_API virtual bool ProcessInput(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual bool PostProcessInput(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual void ClearState(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual GameInputKind GetSupportedReadingKind() const override;
|
|
|
|
GAMEINPUTBASE_API bool ProcessGamepadAnalogState(const FGameInputEventParams& Params, GameInputGamepadState& GamepadState);
|
|
GAMEINPUTBASE_API virtual bool ProcessGamepadButtonState(const FGameInputEventParams& Params, GameInputGamepadState& GamepadState);
|
|
|
|
GameInputGamepadState PreviousState = {};
|
|
|
|
uint32 LastButtonHeldMask = 0;
|
|
|
|
uint32 LastAnalogButtonHeldMask = 0;
|
|
|
|
enum { MaxSupportedButtons = 32 };
|
|
|
|
double RepeatTime[MaxSupportedButtons];
|
|
|
|
/**
|
|
* Keeps track of how many times this gamepad has been processed this frame.
|
|
* Every successful processing of button input in ProcessInput will increment this value.
|
|
* This will get reset at the end of the input frame in PostProcessInput.
|
|
*/
|
|
int32 NumReadingsProcessedThisFrame = 0;
|
|
};
|
|
|
|
struct FGameInputDeviceConfiguration;
|
|
|
|
/**
|
|
* Processor for Controller Input Types
|
|
*
|
|
* Controllers are very similar to Gamepad types, and often can just be
|
|
* a third party controller type that is not natively supported by the "GamepadInputKind".
|
|
* This can include things like instruments, other platform controller types, or other
|
|
* third party input devices.
|
|
*/
|
|
class FGameInputControllerDeviceProcessor : public IGameInputDeviceProcessor
|
|
{
|
|
public:
|
|
GAMEINPUTBASE_API FGameInputControllerDeviceProcessor();
|
|
|
|
protected:
|
|
GAMEINPUTBASE_API virtual bool ProcessInput(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual bool PostProcessInput(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual void ClearState(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual GameInputKind GetSupportedReadingKind() const override;
|
|
|
|
/** Processes Controller buttons (often face buttons, like ABXY or Circle/Triangle/Square/X) */
|
|
GAMEINPUTBASE_API bool ProcessControllerButtonState(const FGameInputEventParams& Params, const FGameInputDeviceConfiguration* Config, IGameInputReading* InputReading);
|
|
|
|
/**
|
|
* Process any axis readings on this controller.
|
|
* This will only process axises that are configured in the given Config.
|
|
*/
|
|
GAMEINPUTBASE_API bool ProcessControllerAxisState(const FGameInputEventParams& Params, const FGameInputDeviceConfiguration* Config, IGameInputReading* InputReading);
|
|
|
|
/**
|
|
* Process the controller switch (also known as the DPad) state
|
|
*/
|
|
GAMEINPUTBASE_API bool ProcessControllerSwitchState(const FGameInputEventParams& Params, const FGameInputDeviceConfiguration* Config, IGameInputReading* InputReading);
|
|
|
|
/** A map of GameInputLabel types to Unreal Engine FKey names. */
|
|
static GAMEINPUTBASE_API const TMap<GameInputLabel, FGamepadKeyNames::Type>& GetGameInputButtonLabelToUnrealName();
|
|
|
|
/** Bitmask of any held buttons from the last frame */
|
|
uint32 LastButtonHeldMask = 0;
|
|
|
|
/** Max number of buttons this processor supports */
|
|
enum { MaxSupportedButtons = 32 };
|
|
|
|
/** Timings of when a key press should be considered a "repeat" key */
|
|
double RepeatTime[MaxSupportedButtons];
|
|
|
|
/** Repeat times for when switches are pressed (aka the DPad) */
|
|
TArray<double> SwitchRepeatTimes;
|
|
|
|
/** Previous frame's axis values */
|
|
TArray<float> PreviousControllerAxisValues;
|
|
|
|
/** Array of switch positions */
|
|
TArray<GameInputSwitchPosition> PreviousSwitchPositions;
|
|
|
|
/**
|
|
* Keeps track of how many times this gamepad has been processed this frame.
|
|
* Every successful processing of button input in ProcessInput will increment this value.
|
|
* This will get reset at the end of the input frame in PostProcessInput.
|
|
*/
|
|
int32 NumReadingsProcessedThisFrame = 0;
|
|
};
|
|
|
|
/**
|
|
* Processor for Keyboard inputs
|
|
*/
|
|
class FGameInputKeyboardDeviceProcessor : public IGameInputDeviceProcessor
|
|
{
|
|
protected:
|
|
GAMEINPUTBASE_API virtual bool ProcessInput(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual void ClearState(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual GameInputKind GetSupportedReadingKind() const override;
|
|
|
|
GAMEINPUTBASE_API void UpdateUnifiedKeyboardState(const FGameInputEventParams& Params, TSet<uint8>& CurrentPressedKeys);
|
|
|
|
inline bool IsKeyPressed(uint8 VirtualKeyCode) const { return LastPressedKeys.Contains(VirtualKeyCode); }
|
|
|
|
GAMEINPUTBASE_API virtual void SetSimulatedCapsLock(bool bVal);
|
|
|
|
TSet<uint8> LastPressedKeys;
|
|
|
|
TMap<uint8, double> KeyRepeatTime;
|
|
|
|
// cannot read actual caps lock state, so necessary to simulate it as a bool toggle
|
|
bool bSimulatedCapsLock;
|
|
};
|
|
|
|
|
|
/**
|
|
* Processor for mouse inputs
|
|
*/
|
|
class FGameInputMouseDeviceProcessor : public IGameInputDeviceProcessor
|
|
{
|
|
public:
|
|
GAMEINPUTBASE_API explicit FGameInputMouseDeviceProcessor(const TSharedPtr<class ICursor>& InCursor);
|
|
|
|
protected:
|
|
GAMEINPUTBASE_API virtual bool ProcessInput(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual void ClearState(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual GameInputKind GetSupportedReadingKind() const override;
|
|
|
|
GAMEINPUTBASE_API virtual bool CanProcessVirtualMouse() const;
|
|
|
|
TSharedPtr<class ICursor> Cursor;
|
|
|
|
GameInputMouseState PreviousMouseState;
|
|
|
|
FVector2D LastMouseOffset;
|
|
|
|
enum { MaxSupportedButtons = 32 };
|
|
double RepeatTime[MaxSupportedButtons];
|
|
|
|
uint32 LastButtonHeldMask;
|
|
};
|
|
|
|
|
|
/**
|
|
* Processor for touch inputs
|
|
*/
|
|
class FGameInputTouchDeviceProcessor : public IGameInputDeviceProcessor
|
|
{
|
|
protected:
|
|
GAMEINPUTBASE_API virtual bool ProcessInput(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual void ClearState(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual GameInputKind GetSupportedReadingKind() const override;
|
|
|
|
struct FTouchData
|
|
{
|
|
FTouchData()
|
|
{
|
|
TouchId = INDEX_NONE;
|
|
Position = FVector2D::ZeroVector;
|
|
Pressure = 0.0f;
|
|
bHasMoved = false;
|
|
bIsActive = false;
|
|
}
|
|
|
|
int64 TouchId;
|
|
FVector2D Position;
|
|
float Pressure;
|
|
bool bHasMoved;
|
|
bool bIsActive;
|
|
};
|
|
TArray<FTouchData> PreviousTouchData;
|
|
int32 ActiveTouchPoints = 0;
|
|
|
|
// The max touch X and Y of the touch region to let us scale input based on the size of the touch area
|
|
int32 MaxTouchX = 1920;
|
|
int32 MaxTouchY = 1080;
|
|
};
|
|
|
|
struct FGameInputDeviceConfiguration;
|
|
struct FGameInputRawDeviceReportData;
|
|
|
|
/**
|
|
* Processor for raw input types (GameInputKindRawDeviceReport)
|
|
*
|
|
* Raw input is very customizable and is very different per-input device, so it requires a lot of configuration.
|
|
* Most of the time it is special analog inputs on custom third party devices. A good example is the Whammy bar on
|
|
* a guitar controller, or maybe some special shifter on a racing wheel that the Game Input API does not pick up by default.
|
|
*/
|
|
class FGameInputRawDeviceProcessor : public IGameInputDeviceProcessor
|
|
{
|
|
protected:
|
|
GAMEINPUTBASE_API virtual bool ProcessInput(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual bool PostProcessInput(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual void ClearState(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual GameInputKind GetSupportedReadingKind() const override;
|
|
|
|
/**
|
|
* Reads the current state of the raw input buffer and populates CurrentRawData and PreviousRawData
|
|
*/
|
|
GAMEINPUTBASE_API const GameInputRawDeviceReportInfo* ReadCurrentRawInputState(const FGameInputEventParams& Params, IGameInputReading* ReadingToUse);
|
|
|
|
|
|
/**
|
|
* Translates the given uint8 RawValue to a float between 0.0 and +1.0, like most gamepad analog "triggers"
|
|
*
|
|
* @param RawValue
|
|
*
|
|
* @return A float between 0.0 and +1.0
|
|
*/
|
|
GAMEINPUTBASE_API constexpr float RawValueToFloatTrigger(const uint8 RawValue) const;
|
|
|
|
/**
|
|
* Translates the given uint8 RawValue to a float between -1.0 and +1.0.
|
|
*
|
|
* @param RawValue
|
|
* @param Deadzone
|
|
*
|
|
* @return A float between -1.0 and +1.0. Will be 0.0 if the value is within the deadzone.
|
|
*/
|
|
GAMEINPUTBASE_API const float RawValueToFloatAnalog(uint8 RawValue, const uint8 DeadZone = 2) const;
|
|
|
|
/**
|
|
* Processes all the current raw input data. This should only be called after we have read our current raw input report
|
|
* or we have manually set the values (i.e. when we clear the input)
|
|
*/
|
|
GAMEINPUTBASE_API bool ProcessAllRawValues(const FGameInputEventParams& Params, const FGameInputDeviceConfiguration* DeviceConfig, const bool bShouldProcessButtons, const bool bShouldProcessAnalog);
|
|
|
|
/**
|
|
* Processes the raw value at the given index as a button bitmask.
|
|
* For every bit in the raw value and treat it as 0 for pressed and 1 for on.
|
|
*/
|
|
GAMEINPUTBASE_API bool ProcessRawInputValueAsBitmask(const FGameInputEventParams& Params, const int32 RawValueIndex, const FGameInputRawDeviceReportData* AxisData);
|
|
|
|
/**
|
|
* Processes the raw value at the given index as a button value. If the value is non-zero, then treat it as pressed.
|
|
* If the value is zero, treat it as unpressed.
|
|
*/
|
|
GAMEINPUTBASE_API bool ProcessRawInputValueAsButton(const FGameInputEventParams& Params, const int32 RawValueIndex, const FGameInputRawDeviceReportData* AxisData);
|
|
|
|
/**
|
|
* Processes the raw value at the given index as an analog value. This will translate the uint8 to a float value
|
|
* and call OnControllerAnalog for it.
|
|
*/
|
|
GAMEINPUTBASE_API bool ProcessRawInputValueAsAanalog(const FGameInputEventParams& Params, const int32 RawValueIndex, const FGameInputRawDeviceReportData* AxisData);
|
|
|
|
/**
|
|
* Processes a pair of raw input indexes. This allows you to combine the values of multiple uint8 axis readings and combine them
|
|
*/
|
|
GAMEINPUTBASE_API bool ProcessRawInputValueAsAanalogPaired(const FGameInputEventParams& Params, const FGameInputRawDeviceReportData* AxisData);
|
|
|
|
/**
|
|
* The current raw input data that is populated by IGameInputRawDeviceReport::GetRawData
|
|
*/
|
|
TArray<uint8> CurrentRawData;
|
|
|
|
/**
|
|
* The previous frame's raw input data that is set at the end of ProcessInput.
|
|
*/
|
|
TArray<uint8> PreviousRawData;
|
|
|
|
/** A struct that contains info about each raw input index */
|
|
struct FPerRawInputIndexData
|
|
{
|
|
// The max number of buttons possibly associated with this raw input data. The raw input data is
|
|
// a uint8, so we can have at maximum a button per-bit, so 8.
|
|
enum { MaxSupportedButtons = 8 };
|
|
|
|
// Stores the times that each button index has been pressed so we can detect key repeats
|
|
double RepeatTime[MaxSupportedButtons];
|
|
|
|
/**
|
|
* A map of key names to int values that is generated dynamically based on the button mapping.
|
|
*/
|
|
TMap<uint32, FName> KeyNameMap;
|
|
};
|
|
|
|
/**
|
|
* A map of an index to some raw data associated with it.
|
|
* This is only used for button evaluation, not analog.
|
|
*/
|
|
TMap<int32, FPerRawInputIndexData> RawInputIndexDataMap;
|
|
|
|
/**
|
|
* Keeps track of how many times this gamepad has been processed this frame.
|
|
* Every successful processing of button input in ProcessInput will increment this value.
|
|
* This will get reset at the end of the input frame in PostProcessInput.
|
|
*/
|
|
int32 NumReadingsProcessedThisFrame = 0;
|
|
};
|
|
|
|
/**
|
|
* Processor for racing wheel types (GameInputKindRacingWheel)
|
|
*
|
|
* Note: Racing wheels are often paired with other device processors like Gamepad/Controller
|
|
* to handle any "normal" buttons that may be on them.
|
|
*/
|
|
class FGameInputRacingWheelProcessor : public IGameInputDeviceProcessor
|
|
{
|
|
public:
|
|
GAMEINPUTBASE_API FGameInputRacingWheelProcessor();
|
|
protected:
|
|
GAMEINPUTBASE_API virtual bool ProcessInput(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual bool PostProcessInput(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual void ClearState(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual GameInputKind GetSupportedReadingKind() const override;
|
|
|
|
/**
|
|
* Returns the deadzone that we would like to use for racing wheel analog inputs.
|
|
*/
|
|
static GAMEINPUTBASE_API const float GetRacingWheelDeadzone();
|
|
|
|
/**
|
|
* Processes the analog inputs of the wheel state (brake/clutch pedals, wheel movement, etc).
|
|
*/
|
|
GAMEINPUTBASE_API bool ProcessWheelAnalogState(const FGameInputEventParams& Params, GameInputRacingWheelState& CurrentWheelState);
|
|
|
|
/**
|
|
* Processes any buttons on the racing wheel (next/previous gears, menu nav, etc);
|
|
*/
|
|
GAMEINPUTBASE_API bool ProcessWheelButtonState(const FGameInputEventParams& Params, GameInputRacingWheelState& CurrentWheelState);
|
|
|
|
/**
|
|
* Keeps track of how many times this gamepad has been processed this frame.
|
|
* Every successful processing of button input in ProcessInput will increment this value.
|
|
* This will get reset at the end of the input frame in PostProcessInput.
|
|
*/
|
|
int32 NumReadingsProcessedThisFrame = 0;
|
|
|
|
/** The previous game input state that was last processed. */
|
|
GameInputRacingWheelState PreviousState;
|
|
|
|
/**
|
|
* Array of repeat times to calculate if a button has been held long enough
|
|
* to receive an IE_REPEAT event.
|
|
*/
|
|
static const uint32 MaxSupportedButtons = 16;
|
|
double RepeatTime[MaxSupportedButtons];
|
|
};
|
|
|
|
|
|
/**
|
|
* Processor for the GameInputKindArcadeStick type.
|
|
*
|
|
* These are typically accessories to "fighting" style games, or other arcade style games.
|
|
*/
|
|
class FGameInputArcadeStickProcessor : public IGameInputDeviceProcessor
|
|
{
|
|
public:
|
|
GAMEINPUTBASE_API FGameInputArcadeStickProcessor();
|
|
|
|
protected:
|
|
|
|
GAMEINPUTBASE_API virtual bool ProcessInput(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual void ClearState(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual GameInputKind GetSupportedReadingKind() const override;
|
|
|
|
/** The previously processed arcade stick state. */
|
|
GameInputArcadeStickState PreviousState;
|
|
|
|
/**
|
|
* Array of repeat times to calculate if a button has been held long enough
|
|
* to receive an IE_REPEAT event.
|
|
*/
|
|
static const uint32 MaxSupportedButtons = 16;
|
|
double RepeatTime[MaxSupportedButtons];
|
|
};
|
|
|
|
/**
|
|
* Processor for the GameInputKindFlightStick type.
|
|
*/
|
|
class FGameInputFlightStickProcessor : public IGameInputDeviceProcessor
|
|
{
|
|
public:
|
|
GAMEINPUTBASE_API FGameInputFlightStickProcessor();
|
|
|
|
protected:
|
|
|
|
GAMEINPUTBASE_API virtual bool ProcessInput(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual bool PostProcessInput(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual void ClearState(const FGameInputEventParams& Params) override;
|
|
GAMEINPUTBASE_API virtual GameInputKind GetSupportedReadingKind() const override;
|
|
|
|
/**
|
|
* Process Flight stick specific buttons.
|
|
*/
|
|
GAMEINPUTBASE_API bool ProcessFlightStickButtons(const FGameInputEventParams& Params, GameInputFlightStickState& State);
|
|
|
|
/**
|
|
* Process the analog values (yaw, pitch, roll, and throttle) of the flight stick
|
|
*/
|
|
GAMEINPUTBASE_API bool ProcessFlightStickAnalog(const FGameInputEventParams& Params, GameInputFlightStickState& State);
|
|
|
|
/**
|
|
* Keeps track of how many times this gamepad has been processed this frame.
|
|
* Every successful processing of button input in ProcessInput will increment this value.
|
|
* This will get reset at the end of the input frame in PostProcessInput.
|
|
*/
|
|
int32 NumReadingsProcessedThisFrame = 0;
|
|
|
|
/** State of the flight stick from the previous frame */
|
|
GameInputFlightStickState PreviousState = {};
|
|
|
|
// Repeat times for any pressed buttons
|
|
static constexpr uint32 MaxSupportedButtons = 32;
|
|
double RepeatTime[MaxSupportedButtons];
|
|
|
|
/** Repeat times for when switches are pressed (aka the DPad) */
|
|
TArray<double> SwitchRepeatTimes;
|
|
};
|
|
|
|
#endif // GAME_INPUT_SUPPORT
|