Plugin doesn't start on Game mode


I wrote a small plugin to get inputs from a joystick device. It works fine when I play my game in the editor, but when I try to play with a packaged version, nothing happens.

Is there some option to enable plugin in the final product ?

Thanks for your answers.

In my tutorial i go over the different types of plugin, and that may be the culprit.

In order for your plugin to be loaded and executed at runtime you will need to set its type to Runtime. This lets the Build tool know that it will need to be included into the shipping package and bound into the monolithic executable. It also means that you will need to ensure that your code works for Win32, and that you link in the correctly versioned libraries too.

I did it. Here are my main files:


    "FileVersion" : 1,
	"FriendlyName" : "Joystick Plugin",
	"Version" : 1,
	"VersionName" : "1.0",
	"CreatedBy" : "LUSAGE",
	"EngineVersion" : 1579795,
	"Description" : "Enable use of joystick",
	"Category" : "Runtime",
    "Modules" :
			"Name" : "JoystickDevice",
			"Type" : "Runtime"


namespace UnrealBuildTool.Rules
    public class JoystickDevice : ModuleRules
        public JoystickDevice(TargetInfo Target)
            PublicIncludePaths .AddRange( new string] { } );
            PrivateIncludePaths.AddRange( new string] { "JoystickDevice/Private", } );

            // Unreal Engine modules
            PrivateDependencyModuleNames.AddRange(new string]

            // Link external libraries
            if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) 
                PrivateDependencyModuleNames.AddRange(new string] { "DX11", "DX11Input" });


#pragma once

#include "Runtime/InputDevice/Public/IInputDeviceModule.h"

class FJoystickDeviceModule : public IInputDeviceModule {
	virtual TSharedPtr< class IInputDevice > CreateInputDevice(const TSharedRef< FGenericApplicationMessageHandler >& InMessageHandler) OVERRIDE;


#include "JoystickDevice.h"
#include "FJoystickDeviceModule.h"
#include "FJoystickDevice.h"

TSharedPtr< class IInputDevice > FJoystickDeviceModule::CreateInputDevice(const TSharedRef< FGenericApplicationMessageHandler >& InMessageHandler)
	return MakeShareable(new FJoystickDevice(InMessageHandler));

IMPLEMENT_MODULE(FJoystickDeviceModule, JoystickDevice)

I also added

AdditionalPlugins.AddRange(new string] { "JoystickDevice" });

in MyProject.Target.cs and

 PublicDependencyModuleNames.AddRange(new string] {  "JoystickDevice", });

in MyProject.Build.cs.

In that case, join us on IRC - we will need to triage this in real time.

Can you post your whole plugin code? i’m really interested in create my own custom input plugin but i really cannot find much documentation about

Sure ! It’s not clean yet and it only works for Windows (I found the integration of the Windows API on the Internet, but I can’t remember where…).


#pragma once

#include "Runtime/InputDevice/Public/IInputDevice.h"

namespace { // Avoid conflict with other Unreal Engine classes

	static const int32 MAX_NUM_CONTROLLER_BUTTONS = 4;

	typedef void *IOJoystickDevicePtr;
	typedef void *IOJoystickManagerPtr;

	struct FJoystickButtonInfo {
		uint8 Value;

	struct FJoystickAxisInfo {
		int32 xValue   =  0;
		int32 yValue   = 0;
		int32 MinValue = 0;
		int32 MaxValue = 65535;

	struct FJoystickDeviceInfo {
		IOJoystickDevicePtr DevicePtr = nullptr;
		TArray<FJoystickButtonInfo> Buttons;
		FJoystickAxisInfo AxisInfo;

	struct FControllerState {
		/** Last frame's button states, so we only send events on edges */

		/** Next time a repeat event should be generated for each button */
		double NextRepeatTime[MAX_NUM_CONTROLLER_BUTTONS];

		/** Raw x analog value */
		int16 xAnalog;

		/** Raw y analog value */
		int16 yAnalog;

		/** Id of the controller */
		int32 ControllerId;

		FJoystickDeviceInfo Device;

* Joystick input interface.
class FJoystickDevice : public IInputDevice
	explicit FJoystickDevice(const TSharedRef<FGenericApplicationMessageHandler>& InMessageHandler);
	virtual ~FJoystickDevice();

	/** Tick the interface (e.g. check for new controllers) */
	virtual void Tick(float DeltaTime) OVERRIDE;

	/** Poll for controller state and send events if needed */
	virtual void SendControllerEvents() OVERRIDE;

	/** Set which MessageHandler will get the events from SendControllerEvents. */
	virtual void SetMessageHandler(const TSharedRef< FGenericApplicationMessageHandler >& InMessageHandler) OVERRIDE;

	/** Exec handler to allow console commands to be passed through for debugging */
	virtual bool Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar) OVERRIDE;

	* IForceFeedbackSystem pass through functions
	virtual void SetChannelValue(int32 ControllerId, FForceFeedbackChannelType ChannelType, float Value) OVERRIDE;
	virtual void SetChannelValues(int32 ControllerId, const FForceFeedbackValues &values) OVERRIDE;

	/** Names of all the buttons */
	EControllerButtons::Type Buttons[MAX_NUM_CONTROLLER_BUTTONS];

	/** Controller state */
	FControllerState ControllerState;

	/** 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;

	IOJoystickManagerPtr JoystickManager;

	TSharedRef< FGenericApplicationMessageHandler > MessageHandler;


#include "JoystickDevice.h"
#include "FJoystickDevice.h"
#include "JoystickUtils.h"

namespace IOJoystickDevice {
	extern IOJoystickManagerPtr CreateManager();
	extern bool OpenManager(IOJoystickManagerPtr Manager);
	extern void ReleaseManager(IOJoystickManagerPtr Manager);

	extern bool OpenDevice(IOJoystickManagerPtr Manager, FJoystickDeviceInfo &Device);
	extern void CloseDevice(IOJoystickManagerPtr Manager, FJoystickDeviceInfo &Device);
	extern bool GetDeviceState(IOJoystickManagerPtr Manager, FJoystickDeviceInfo &Device);

#include "win_callbacks.h"


FORCEINLINE IOJoystickManagerPtr IOJoystickDevice::CreateManager() { return nullptr; }
FORCEINLINE bool IOJoystickDevice::OpenManager(IOJoystickManagerPtr Manager) { return false; }
FORCEINLINE void IOJoystickDevice::ReleaseManager(IOJoystickManagerPtr Manager) {}

FORCEINLINE bool IOJoystickDevice::OpenDevice(IOJoystickManagerPtr Manager, FJoystickDeviceInfo &Device) { Device.DevicePtr = nullptr; return false; }
FORCEINLINE void IOJoystickDevice::CloseDevice(IOJoystickManagerPtr Manager, FJoystickDeviceInfo &Device) {}
FORCEINLINE bool IOJoystickDevice::GetDeviceState(IOJoystickManagerPtr Manager, FJoystickDeviceInfo &Device) { return false; }


FJoystickDevice::FJoystickDevice(const TSharedRef<FGenericApplicationMessageHandler>& InMessageHandler) :
	FMemory::Memzero(&ControllerState, sizeof(FControllerState));

	InitialButtonRepeatDelay = 0.2f;
	ButtonRepeatDelay = 0.1f;

	Buttons[0] = EControllerButtons::FaceButtonBottom;
	Buttons[1] = EControllerButtons::FaceButtonTop;
	Buttons[2] = EControllerButtons::SpecialRight;
	Buttons[3] = EControllerButtons::FaceButtonRight;

	// Init Joystick Manager
	JoystickManager = IOJoystickDevice::CreateManager();
	if (!JoystickManager)

	if (!IOJoystickDevice::OpenManager(JoystickManager)) {
		JoystickManager = nullptr;
		JD_CERR("Failed to open a joystick manager!");

	JD_COUT("Joystick manager successfully created.");

	if (ControllerState.Device.DevicePtr)
		IOJoystickDevice::CloseDevice(JoystickManager, ControllerState.Device);
	if (JoystickManager)

void FJoystickDevice::Tick(float DeltaTime)
	// Get the joystick device if it's not already aquiered
	if (JoystickManager && !ControllerState.Device.DevicePtr) 
		if (!IOJoystickDevice::OpenDevice(JoystickManager, ControllerState.Device)) {
			JD_CERR("Failed to connect with a joystick!");
		} else {
			JD_COUT("Joystick successfully connected.");
			if (GEngine)
				GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Yellow, TEXT("Joystick successfully connected."));
	if (GEngine)
		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("Tick Test."));

void FJoystickDevice::SendControllerEvents()
	if (!JoystickManager || !ControllerState.Device.DevicePtr)
	if (!IOJoystickDevice::GetDeviceState(JoystickManager, ControllerState.Device)) {
		JD_CERR("Failed to get joystick state!");

	float x =   2.0f * float(ControllerState.Device.AxisInfo.xValue - ControllerState.Device.AxisInfo.MinValue) / float(ControllerState.Device.AxisInfo.MaxValue - ControllerState.Device.AxisInfo.MinValue) - 1.0f;
	float y = -(2.0f * float(ControllerState.Device.AxisInfo.yValue - ControllerState.Device.AxisInfo.MinValue) / float(ControllerState.Device.AxisInfo.MaxValue - ControllerState.Device.AxisInfo.MinValue) - 1.0f);

	JD_COUT("Joystick analog: (%f | %f)", x, y);

	MessageHandler->OnControllerAnalog(EControllerButtons::LeftAnalogX, ControllerState.ControllerId, x);
	MessageHandler->OnControllerAnalog(EControllerButtons::LeftAnalogY, ControllerState.ControllerId, y);

	const double CurrentTime = FPlatformTime::Seconds();

	for (int i = 0; i < MAX_NUM_CONTROLLER_BUTTONS; ++i) {
		uint8   currentState	= ControllerState.Device.Buttons*.Value;
		uint8&  previousState	= ControllerState.ButtonStates*;
		double& nextRepeatTime	= ControllerState.NextRepeatTime*;

		if (currentState != previousState) {
			if (currentState) {
				MessageHandler->OnControllerButtonPressed(Buttons*, ControllerState.ControllerId, false);
				nextRepeatTime = CurrentTime + InitialButtonRepeatDelay;
				JD_COUT("Button %d is pressed", i);
			else {
				MessageHandler->OnControllerButtonReleased(Buttons*, ControllerState.ControllerId, false);
				JD_COUT("Button %d is released", i);
		} else if (currentState && nextRepeatTime <= CurrentTime) {
			MessageHandler->OnControllerButtonPressed(Buttons*, ControllerState.ControllerId, true);
			nextRepeatTime = CurrentTime + ButtonRepeatDelay;

		previousState = currentState;

void FJoystickDevice::SetMessageHandler(const TSharedRef< FGenericApplicationMessageHandler >& InMessageHandler)
	MessageHandler = InMessageHandler;

bool FJoystickDevice::Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar)
	return false; 

void FJoystickDevice::SetChannelValue(int32 ControllerId, FForceFeedbackChannelType ChannelType, float Value)
	// Not implemented yet (and probably not necessary in our context, patient don't need aptic feedback)

void FJoystickDevice::SetChannelValues(int32 ControllerId, const FForceFeedbackValues &values)
	// Not implemented yet (and probably not necessary in our context, patient don't need aptic feedback)


#pragma once



#define STRICT 
#ifndef _WIN32_DCOM 
#define _WIN32_DCOM 

#include "AllowWindowsPlatformTypes.h"

#include <windows.h> 
#include <stdio.h> 
#include <tchar.h> 
#include <commctrl.h> 
#include <basetsd.h> 

#pragma warning(push) 
#pragma warning(disable:6000 28251) 
#include <dinput.h> 
#pragma warning(pop) 

#include <dinputd.h> 
#include <assert.h> 
#include <oleauto.h> 
#include <shellapi.h> 
#include <wbemidl.h>

#include "JoystickDevice.h"
#include "JoystickUtils.h"
#include "FJoystickDevice.h"

namespace {

		DWORD dwVidPid;

	struct FJoystickManager {
		XINPUT_DEVICE_NODE*     pXInputDeviceList = nullptr;
		LPDIRECTINPUT8          pDI = nullptr;
		DIJOYCONFIG				PreferredJoyCfg;
		bool					bFilterOutXinputDevices = false;

		struct {
			DIJOYCONFIG* pPreferredJoyCfg;
			bool bPreferredJoyCfgValid;
		} enumContext;

	struct FJoystickHandler {
		FJoystickManager *Manager;
		FJoystickDeviceInfo &DeviceInfo;

		FORCEINLINE FJoystickHandler(FJoystickManager *InManager, FJoystickDeviceInfo &InDeviceInfo) :

	* Enum each PNP device using WMI and check each device ID to see if it contains "IG_" (ex. "VID_045E&PID_028E&IG_00").
	* If it does, then it's an XInput device. Unfortunately this information can not be found by just using DirectInput.
	* Checking against a VID/PID of 0x028E/0x045E won't find 3rd party or future XInput devices.
	* This function stores the list of xinput devices in a linked list at pXInputDeviceList, and IsXInputDevice() searchs that linked list.
	FORCEINLINE HRESULT SetupForIsXInputDevice(FJoystickManager *Manager) {
		IWbemServices*			pIWbemServices = nullptr;
		IEnumWbemClassObject*	pEnumDevices = nullptr;
		IWbemLocator*			pIWbemLocator = nullptr;
		IWbemClassObject*		pDevices[20] = { 0 };
		BSTR					bstrDeviceID = nullptr;
		BSTR					bstrClassName = nullptr;
		BSTR					bstrNamespace = nullptr;
		DWORD					uReturned = 0;
		bool					bCleanupCOM = false;
		UINT					iDevice = 0;
		VARIANT					var;
		HRESULT					hr;

		// CoInit if needed 
		bCleanupCOM = SUCCEEDED(CoInitialize(nullptr));

		// Create WMI 
		if (FAILED(hr = CoCreateInstance(__uuidof(WbemLocator), nullptr, CLSCTX_INPROC_SERVER, __uuidof(IWbemLocator), (LPVOID*)&pIWbemLocator)) || !pIWbemLocator) {
			JD_CERR("Failed to create COM instance!");
			goto LCleanup;

		// Create BSTRs for WMI 
		bstrNamespace = SysAllocString(L"\\\\.\\root\\cimv2"); if (!bstrNamespace) goto LCleanup;
		bstrDeviceID = SysAllocString(L"DeviceID");           if (!bstrDeviceID)  goto LCleanup;
		bstrClassName = SysAllocString(L"Win32_PNPEntity");    if (!bstrClassName) goto LCleanup;

		// Connect to WMI  
		if (FAILED(hr = pIWbemLocator->ConnectServer(bstrNamespace, nullptr, nullptr, 0L, 0L, nullptr, nullptr, &pIWbemServices)) || !pIWbemServices) {
			JD_CERR("Failed to connect WMI server!");
			goto LCleanup;

		// Switch security level to IMPERSONATE 

		// Get list of Win32_PNPEntity devices 
		if (FAILED(hr = pIWbemServices->CreateInstanceEnum(bstrClassName, 0, nullptr, &pEnumDevices)) || !pEnumDevices) {
			JD_CERR("Failed to get the list of Win32_PNPEntity devices!");
			goto LCleanup;

		// Loop over all devices 
		for (;;) {
			// Get 20 at a time 
			if (FAILED(hr = pEnumDevices->Next(10000, 20, pDevices, &uReturned))) {
				JD_CERR("Failed to get devices!");
				goto LCleanup;
			if (uReturned == 0)

			for (iDevice = 0; iDevice < uReturned; ++iDevice) {
				if (!pDevices[iDevice])

				// For each device, get its device ID 
				if (SUCCEEDED(pDevices[iDevice]->Get(bstrDeviceID, 0L, &var, nullptr, nullptr)) && var.vt == VT_BSTR && var.bstrVal) {
					// Check if the device ID contains "IG_".  If it does, then it's an XInput device 
					// Unfortunately this information can not be found by just using DirectInput  
					if (wcsstr(var.bstrVal, L"IG_")) {
						// If it does, then get the VID/PID from var.bstrVal 
						DWORD dwPid = 0, dwVid = 0;
						WCHAR* strVid = wcsstr(var.bstrVal, L"VID_");
						if (strVid && swscanf(strVid, L"VID_%4X", &dwVid) != 1)
							dwVid = 0;
						WCHAR* strPid = wcsstr(var.bstrVal, L"PID_");
						if (strPid && swscanf(strPid, L"PID_%4X", &dwPid) != 1)
							dwPid = 0;

						DWORD dwVidPid = MAKELONG(dwVid, dwPid);

						// Add the VID/PID to a linked list 
						if (pNewNode) {
							pNewNode->dwVidPid = dwVidPid;
							pNewNode->pNext = Manager->pXInputDeviceList;
							Manager->pXInputDeviceList = pNewNode;

		if (bstrNamespace)
		if (bstrDeviceID)
		if (bstrClassName)
		for (iDevice = 0; iDevice < 20; iDevice++)

		return hr;

	* Returns true if the DirectInput device is also an XInput device.
	* Call SetupForIsXInputDevice() before, and CleanupForIsXInputDevice() after
	FORCEINLINE bool IsXInputDevice(const GUID* pGuidProductFromDirectInput, FJoystickManager *Manager) {
		// Check each xinput device to see if this device's vid/pid matches 
		XINPUT_DEVICE_NODE* pNode = Manager->pXInputDeviceList;
		while (pNode) {
			if (pNode->dwVidPid == pGuidProductFromDirectInput->Data1)
				return true;
			pNode = pNode->pNext;

		return false;

	* Cleanup needed for IsXInputDevice()
	FORCEINLINE void CleanupForIsXInputDevice(FJoystickManager *Manager) {
		// Cleanup linked list 
		XINPUT_DEVICE_NODE* pNode = Manager->pXInputDeviceList;
		while (pNode) {
			XINPUT_DEVICE_NODE* pDelete = pNode;
			pNode = pNode->pNext;
			delete pDelete;

	* Called once for each enumerated joystick.
	* If we find one, create a device interface on it so we can play with it.
	static BOOL CALLBACK EnumJoysticksCallback(const DIDEVICEINSTANCE* pdidInstance, VOID* pContext) {
		FJoystickHandler *Handler = reinterpret_cast<FJoystickHandler*>(pContext);
		auto Manager = Handler->Manager;
		auto &pJoystick = reinterpret_cast<LPDIRECTINPUTDEVICE8&>(Handler->DeviceInfo.DevicePtr);

		if (Manager->bFilterOutXinputDevices && IsXInputDevice(&pdidInstance->guidProduct, Manager)) {
			JD_COUT("This joystick is not a XInputDevice.");

		// Skip anything other than the perferred joystick device as defined by the control panel.   
		// Instead you could store all the enumerated joysticks and let the user pick. 
		if (Manager->enumContext.bPreferredJoyCfgValid && !IsEqualGUID(pdidInstance->guidInstance, Manager->enumContext.pPreferredJoyCfg->guidInstance)) {
			JD_COUT("This joystick doesn\'t match the requiered configuration.");

		// Obtain an interface to the enumerated joystick. 
		// If it failed, then we can't use this joystick. (Maybe the user unplugged it while we were in the middle of enumerating it.) 
		if (FAILED(Manager->pDI->CreateDevice(pdidInstance->guidInstance, &pJoystick, nullptr))) {
			JD_COUT("Failed to create this joystick device.");

		// Stop enumeration. Note: we're just taking the first joystick we get. You could store all the enumerated joysticks and let the user pick. 
		JD_COUT("End of the joystick enumeration");
		return DIENUM_STOP;

	* Callback function for enumerating objects (axes, buttons, POVs) on a joystick.
	* This function enables user interface elements for objects that are found to exist, and scales axes min/max values.
	static BOOL CALLBACK EnumObjectsCallback(const DIDEVICEOBJECTINSTANCE* pdidoi, VOID* pContext) {
		FJoystickHandler *Handler = reinterpret_cast<FJoystickHandler*>(pContext);
		auto &DeviceInfo = Handler->DeviceInfo;
		auto &pJoystick = reinterpret_cast<LPDIRECTINPUTDEVICE8&>(Handler->DeviceInfo.DevicePtr);

		// For axes that are returned, set the DIPROP_RANGE property for the 
		// enumerated axis in order to scale min/max values. 
		if (pdidoi->dwType & DIDFT_AXIS) {
			diprg.diph.dwSize = sizeof(DIPROPRANGE);
			diprg.diph.dwHeaderSize = sizeof(DIPROPHEADER);
			diprg.diph.dwHow = DIPH_BYID;
			diprg.diph.dwObj = pdidoi->dwType; // Specify the enumerated axis 

			// Get the range for the axis 
			HRESULT hr = pJoystick->GetProperty(DIPROP_RANGE, &diprg.diph);
			switch (hr) {
				JD_CERR("Failed to set joystick property: Invalid parameter!");
				return DIENUM_STOP;
				JD_CERR("Failed to set joystick property: Not initialized!");
				return DIENUM_STOP;
				JD_CERR("Failed to set joystick property: Object not found!");
				return DIENUM_STOP;
				JD_CERR("Failed to set joystick property: Unknown error code (%#x)!", hr);
				return DIENUM_STOP;

			DeviceInfo.AxisInfo.MinValue = diprg.lMin;
			DeviceInfo.AxisInfo.MaxValue = diprg.lMax;


FORCEINLINE IOJoystickManagerPtr IOJoystickDevice::CreateManager() {
	return new FJoystickManager();

FORCEINLINE void IOJoystickDevice::ReleaseManager(IOJoystickManagerPtr JoystickManager) {
	FJoystickManager* Manager = reinterpret_cast<FJoystickManager*>(JoystickManager);

	delete Manager;

FORCEINLINE bool IOJoystickDevice::OpenManager(IOJoystickManagerPtr JoystickManager) {
	FJoystickManager* Manager = reinterpret_cast<FJoystickManager*>(JoystickManager);

	// Register with the DirectInput subsystem and get a pointer to a IDirectInput interface we can use. 
	// Create a DInput object 
	if (FAILED(DirectInput8Create(GetModuleHandle(NULL), DIRECTINPUT_VERSION, IID_IDirectInput8, (VOID**)&Manager->pDI, nullptr))) {
		JD_CERR("Failed to create DInput object!");
		return false;

	if (Manager->bFilterOutXinputDevices)

	FMemory::Memzero(&Manager->PreferredJoyCfg, sizeof(Manager->PreferredJoyCfg));
	Manager->enumContext.pPreferredJoyCfg = &Manager->PreferredJoyCfg;
	Manager->enumContext.bPreferredJoyCfgValid = false;

	if (FAILED(Manager->pDI->QueryInterface(IID_IDirectInputJoyConfig8, (void**)&Manager->pJoyConfig))) {
		JD_CERR("Failed to query joystick interface!");
		return false;
	Manager->PreferredJoyCfg.dwSize = sizeof(Manager->PreferredJoyCfg);

	return true;

FORCEINLINE bool IOJoystickDevice::OpenDevice(IOJoystickManagerPtr JoystickManager, FJoystickDeviceInfo &DeviceInfo) {
	FJoystickManager* Manager = reinterpret_cast<FJoystickManager*>(JoystickManager);
	auto &pJoystick = reinterpret_cast<LPDIRECTINPUTDEVICE8&>(DeviceInfo.DevicePtr);

	if (SUCCEEDED(Manager->pJoyConfig->GetConfig(0, &Manager->PreferredJoyCfg, DIJC_GUIDINSTANCE))) // This function is expected to fail if no joystick is attached 
		Manager->enumContext.bPreferredJoyCfgValid = true;

	// Look for a simple joystick we can use
	FJoystickHandler joystickHandler = { Manager, DeviceInfo };
	if (FAILED(Manager->pDI->EnumDevices(DI8DEVCLASS_GAMECTRL, EnumJoysticksCallback, &joystickHandler, DIEDFL_ATTACHEDONLY))) {
		JD_CERR("Failed to enumerate devices!");
		return false;

	if (Manager->bFilterOutXinputDevices)

	// Make sure we got a joystick 
	if (!pJoystick) {
		JD_CERR("Failed to get a joystick!");
		return false;

	// Set the data format to "simple joystick" - a predefined data format  
	// A data format specifies which controls on a device we are interested in, 
	// and how they should be reported. This tells DInput that we will be 
	// passing a DIJOYSTATE structure to IDirectInputDevice::GetDeviceState(). 
	if (FAILED(pJoystick->SetDataFormat(&c_dfDIJoystick))) {
		JD_CERR("Failed to initialize joystick!");
		return false;

	// Enumerate the joystick objects. The callback function enabled user 
	// interface elements for objects that are found, and sets the min/max 
	// values property for discovered axes. 
	if (FAILED(pJoystick->EnumObjects(EnumObjectsCallback, &joystickHandler, DIDFT_ALL))) {
		JD_CERR("Failed to enumarate joystick objects!");
		return false;


	return true;

FORCEINLINE void IOJoystickDevice::CloseDevice(IOJoystickManagerPtr JoystickManager, FJoystickDeviceInfo &DeviceInfo) {
	auto &pJoystick = reinterpret_cast<LPDIRECTINPUTDEVICE8&>(DeviceInfo.DevicePtr);

	// Unacquire the device one last time just in case  
	// the app tried to exit while the device is still acquired. 
	if (pJoystick)

	// Release any DirectInput objects. 

FORCEINLINE bool IOJoystickDevice::GetDeviceState(IOJoystickManagerPtr JoystickManager, FJoystickDeviceInfo &DeviceInfo) {
	FJoystickManager* Manager = reinterpret_cast<FJoystickManager*>(JoystickManager);
	auto &pJoystick = reinterpret_cast<LPDIRECTINPUTDEVICE8&>(DeviceInfo.DevicePtr);

	DIJOYSTATE js;				// DInput joystick state  

	// Poll the device to read the current state 
	if (FAILED(pJoystick->Poll())) {
		// DInput is telling us that the input stream has been 
		// interrupted. We aren't tracking any state between polls, so 
		// we don't have any special reset that needs to be done. We 
		// just re-acquire and try again. 
		do {
			hr = pJoystick->Acquire();
		} while (hr == DIERR_INPUTLOST);

		switch (hr) {
		case DI_OK:
			// hr may be DIERR_OTHERAPPHASPRIO or other errors.  This 
			// may occur when the app is minimized or in the process of  
			// switching, so just try again later  
			return false;
			JD_CERR("Failed to poll the joystick: Invalid parameter!");
			return false;
			JD_CERR("Failed to poll the joystick: Not initialized!");
			return false;
			JD_CERR("Failed to poll the joystick: Already aquiered by another app with a higher priority!");
			return false;
			JD_CERR("Failed to poll the joystick: Unknown error code (%#x)!", hr);
			return false;

	// Get the input's device state 
	if (FAILED(pJoystick->GetDeviceState(sizeof(DIJOYSTATE), &js))) {
		JD_CERR("Failed to get joystick device state!");
		return false; // The device should have been acquired during the Poll() 

	// Update parameters
	DeviceInfo.AxisInfo.xValue = js.lX;
	DeviceInfo.AxisInfo.yValue = js.lY;
	for (int32 i = 0; i < MAX_NUM_CONTROLLER_BUTTONS; ++i)
		DeviceInfo.Buttons*.Value = js.rgbButtons*;

	return true;

#include "HideWindowsPlatformTypes.h"


I solved my problem, abandoning the idea of ​​using a plugin. I just created another module in my project and it works fine.

By doing that I may have understood what the issue was. In JoystickDevice.Build.cs, I tried to link the module “InputDevice”

 PrivateDependencyModuleNames.AddRange(new string] { ..., "InputDevice", }); 

whose only has an editor dll. Then, my plugin has probably failed to load (or be built) in game mode (without error message).
Just changing “InputeDevice” by “InputCore” should do the job.