Initial plugin commit

Author: sswires

.gitignore

@@ -0,0 +1,2 @@
+Binaries/
+Intermediate/

OnDeck.uplugin

@@ -0,0 +1,23 @@
+{
+	"FileVersion": 3,
+	"Version": 1,
+	"VersionName": "1.0",
+	"FriendlyName": "OnDeck",
+	"Description": "Provides detection for the presence of a Steam Deck and applies relevant device profiles.",
+	"Category": "Other",
+	"CreatedBy": "Stephen Swires",
+	"CreatedByURL": "https://swires.me",
+	"DocsURL": "",
+	"MarketplaceURL": "",
+	"CanContainContent": true,
+	"IsBetaVersion": false,
+	"IsExperimentalVersion": false,
+	"Installed": false,
+	"Modules": [
+		{
+			"Name": "OnDeck",
+			"Type": "Runtime",
+			"LoadingPhase": "PreDefault"
+		}
+	]
+}

README.md

@@ -1,2 +1,9 @@
-# UE-OnDeck
+# OnDeck
 An Unreal Engine plugin that provides detection utilites for the Steam Deck and Big Picture mode.
+
+**Note:** This is WIP and untested.
+
+## Features
+* Provides C++ and Blueprint API to query Big Picture status and whether the game in running on a Steam Deck.
+* Support the on-screen keyboard if running in Big Picture mode.
+* Optionally apply a device profile if the Steam Deck is detected.

Resources/Icon128.png

@@ -0,0 +1,39 @@
+// Copyright Stephen Swires. All Rights Reserved.
+
+using UnrealBuildTool;
+
+public class OnDeck : ModuleRules
+{
+	public bool IsPlatformSupported => Target.Platform == UnrealTargetPlatform.Linux || Target.Platform == UnrealTargetPlatform.Win64;
+	public string IsPlatformSupportedString => IsPlatformSupported ? "1" : "0";
+	
+	public OnDeck(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+		
+		PublicDependencyModuleNames.AddRange(new string[]
+		{
+			"Core",
+		});
+		
+		PrivateDependencyModuleNames.AddRange(new string[] 
+		{
+			"CoreUObject",
+			"Engine",
+			"DeveloperSettings",
+		});
+		
+		PublicDefinitions.Add($"ONDECK_STEAM_API_AVAILABLE={IsPlatformSupportedString}");
+
+		if (IsPlatformSupported)
+		{
+			PrivateDependencyModuleNames.AddRange(new string[]
+			{
+                "Slate",
+				"SteamShared",
+			});
+			
+			AddEngineThirdPartyPrivateStaticDependencies(Target, "Steamworks");
+		}
+	}
+}

Source/OnDeck/OnDeck.Build.cs

@@ -0,0 +1,124 @@
+// Copyright Stephen Swires. All Rights Reserved.
+
+#include "OnDeck.h"
+#include "SteamSharedModule.h"
+#include "Steam/OnDeckSettings.h"
+#include "OnDeckLogChannels.h"
+#include "DeviceProfiles/DeviceProfileManager.h"
+
+#if ONDECK_STEAM_API_AVAILABLE
+	#include "steam/steam_api.h"
+	#include "steam/isteamutils.h"
+	#include "Slate/SteamBigPictureTextField.h"
+#endif
+
+#if !UE_BUILD_SHIPPING
+namespace OnDeckConsoleVariables
+{
+	TAutoConsoleVariable CvarFakeRunningOnSteamDeck(
+		TEXT("OnDeck.FakeRunningOnSteamDeck"),
+		false,
+		TEXT("Fake running on Steam Deck for testing purposes."),
+		ECVF_Default
+	);
+
+	TAutoConsoleVariable CvarFakeRunningInSteamBigPicture(
+		TEXT("OnDeck.FakeRunningInSteamBigPicture"),
+		false,
+		TEXT("Fake running in Steam Big Picture mode for testing purposes."),
+		ECVF_Default
+	);
+}
+#endif
+
+void FOnDeckModule::StartupModule()
+{
+#if ONDECK_STEAM_API_AVAILABLE
+	// Get Steam API through SteamShared module
+	if (!FSteamSharedModule::IsAvailable() || !FSteamSharedModule::Get().AreSteamDllsLoaded() || !SteamUtils())
+	{
+		// Steam API isn't available
+		return;
+	}
+
+	// cache values of Steam Deck and Big Picture mode status
+	bIsRunningOnSteamDeck = SteamUtils()->IsSteamRunningOnSteamDeck();
+	bIsRunningInSteamBigPicture = SteamUtils()->IsSteamInBigPictureMode();
+
+	const UOnDeckSettings* OnDeckSettings = GetDefault<UOnDeckSettings>();
+	
+	// check to see if we should enable the Steam Deck device profile
+	if (OnDeckSettings->bEnableDeviceProfile)
+	{
+		// we haven opted into the device profile functionality, check if it should be enabled
+		CheckDeviceProfile(OnDeckSettings->DeviceProfileName);
+	}
+
+	// set the custom virtual keyboard handler if enabled
+	if (OnDeckSettings->bEnableVirtualKeyboard && bIsRunningInSteamBigPicture)
+	{
+		FSlateApplication::Get().OverridePlatformTextField(MakeUnique<FSteamBigPictureTextField>());
+		UE_LOGFMT(LogOnDeck, Log, "Overriding virtual keyboard for Steam Big Picture mode.");
+	}
+#endif
+}
+
+void FOnDeckModule::ShutdownModule()
+{
+}
+
+bool FOnDeckModule::IsRunningOnSteamDeck() const
+{
+#if !UE_BUILD_SHIPPING
+	if (OnDeckConsoleVariables::CvarFakeRunningOnSteamDeck.GetValueOnGameThread())
+	{
+		return true;
+	}
+#endif
+
+	return bIsRunningOnSteamDeck;
+}
+
+bool FOnDeckModule::IsRunningInSteamBigPicture() const
+{
+#if !UE_BUILD_SHIPPING
+	if (OnDeckConsoleVariables::CvarFakeRunningInSteamBigPicture.GetValueOnGameThread())
+	{
+		return true;
+	}
+
+	if (IsRunningOnSteamDeck())
+	{
+		// Steam Deck is always in Big Picture mode so if we're "emulating" then we should return true here as well
+		return true;
+	}
+#endif
+	
+	return bIsRunningInSteamBigPicture;
+}
+
+void FOnDeckModule::CheckDeviceProfile(const FString& InDeviceProfileName)
+{
+	if (!bIsRunningOnSteamDeck)
+	{
+		// not running on a Steam Deck, ignore
+		UE_LOGFMT(LogOnDeck, Verbose, "Not running on Steam Deck, skipping device profile.");
+		return;
+	}
+
+	const FString DeviceProfileName = InDeviceProfileName.IsEmpty() ? TEXT("SteamDeck") : InDeviceProfileName;
+	UDeviceProfileManager& DeviceProfileManager = UDeviceProfileManager::Get();
+	UDeviceProfile* SteamDeckProfile = DeviceProfileManager.FindProfile(DeviceProfileName);
+
+	if (!SteamDeckProfile)
+	{
+		// Steam Deck profile already exists, no need to create it
+		UE_LOGFMT(LogOnDeck, Error, "Steam Deck device profile \"{0}\" does not exist.", DeviceProfileName);
+		return;
+	}
+	
+	DeviceProfileManager.SetOverrideDeviceProfile(SteamDeckProfile);
+	UE_LOGFMT(LogOnDeck, Log, "Steam Deck device profile \"{0}\" applied.", DeviceProfileName);
+}
+
+IMPLEMENT_MODULE(FOnDeckModule, OnDeck)

Source/OnDeck/Private/OnDeck.cpp

@@ -0,0 +1,28 @@
+// Copyright Stephen Swires. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Modules/ModuleManager.h"
+#include "IOnDeckModule.h"
+
+class FOnDeckModule : public IOnDeckModule
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule() override;
+	virtual void ShutdownModule() override;
+	
+	/** IOnDeckModuleInterface implementation */
+	virtual bool IsRunningOnSteamDeck() const override;
+	virtual bool IsRunningInSteamBigPicture() const override;
+
+private:
+
+	void CheckDeviceProfile(const FString& InDeviceProfileName);
+
+	bool bIsRunningOnSteamDeck = false;
+	bool bIsRunningInSteamBigPicture = false;
+	
+};

Source/OnDeck/Private/OnDeck.h

@@ -0,0 +1,5 @@
+// Copyright Stephen Swires. All Rights Reserved.
+
+#include "OnDeckLogChannels.h"
+
+DEFINE_LOG_CATEGORY(LogOnDeck);

Source/OnDeck/Private/OnDeckLogChannels.cpp

@@ -0,0 +1,8 @@
+// Copyright Stephen Swires. All Rights Reserved.
+
+#pragma once
+
+#include "Logging/LogMacros.h"
+#include "Logging/StructuredLog.h"
+
+DECLARE_LOG_CATEGORY_EXTERN(LogOnDeck, Log, All);

Source/OnDeck/Private/OnDeckLogChannels.h

@@ -0,0 +1,94 @@
+// Copyright Stephen Swires. All Rights Reserved.
+
+#include "SteamBigPictureTextField.h"
+#include "OnDeckLogChannels.h"
+
+#if ONDECK_STEAM_API_AVAILABLE
+	#include "steam/isteamutils.h"
+#endif
+
+FSteamBigPictureTextField::FSteamBigPictureTextField()
+#if ONDECK_STEAM_API_AVAILABLE
+	: GamepadTextInputDismissed(this, &FSteamBigPictureTextField::OnGamepadTextInputDismissed)
+#endif
+{
+}
+
+void FSteamBigPictureTextField::ShowVirtualKeyboard(bool bShow, int32 UserIndex, TSharedPtr<IVirtualKeyboardEntry> TextEntryWidget)
+{
+#if ONDECK_STEAM_API_AVAILABLE
+	const bool bMultiLineEntry = TextEntryWidget->IsMultilineEntry();
+	const bool bPasswordEntry = TextEntryWidget->GetVirtualKeyboardType() == Keyboard_Password;
+	
+	const auto HintTextChar = StringCast<UTF8CHAR>(*TextEntryWidget->GetHintText().ToString());
+	const auto PlaceholderTextChar = StringCast<UTF8CHAR>(*TextEntryWidget->GetText().ToString());
+	
+	const EGamepadTextInputMode TextInputMode = bPasswordEntry ?
+		EGamepadTextInputMode::k_EGamepadTextInputModePassword :
+		EGamepadTextInputMode::k_EGamepadTextInputModeNormal;
+	
+	const EGamepadTextInputLineMode LineInputMode = bMultiLineEntry ?
+		EGamepadTextInputLineMode::k_EGamepadTextInputLineModeSingleLine :
+		EGamepadTextInputLineMode::k_EGamepadTextInputLineModeMultipleLines;
+
+	if (SteamUtils()->ShowGamepadTextInput(TextInputMode,
+                                           LineInputMode,
+                                           reinterpret_cast<const char*>(HintTextChar.Get()),
+                                           0,
+                                           reinterpret_cast<const char*>(PlaceholderTextChar.Get())
+	))
+	{
+		UE_LOGFMT(LogOnDeck, Verbose, "Showing virtual keyboard.");
+	
+		// virtual keyboard shown, so store the widget that requested it
+		CurrentTextEntryWidget = TextEntryWidget;
+	}
+	else
+	{
+		UE_LOGFMT(LogOnDeck, Warning, "Failed to show virtual keyboard. Overlay might be disabled.");
+	}
+#endif
+}
+
+bool FSteamBigPictureTextField::AllowMoveCursor()
+{
+	return true;
+}
+
+#if ONDECK_STEAM_API_AVAILABLE
+void FSteamBigPictureTextField::OnGamepadTextInputDismissed(GamepadTextInputDismissed_t* Param)
+{
+	const bool bSubmitted = Param->m_bSubmitted;
+	const uint32 TextLength = Param->m_unSubmittedText;
+
+	// delegate back to the game thread to handle setting text, this is going to be called from the online thread
+	AsyncTask(ENamedThreads::GameThread, [this, bSubmitted, TextLength]()
+	{
+		if (CurrentTextEntryWidget.IsValid())
+		{
+			if (bSubmitted)
+			{
+				// get text entered from steam API
+				const uint32 BufferLength = TextLength + 1;
+				TArray<char, TInlineAllocator<64>> EnteredText;
+				EnteredText.SetNumZeroed(BufferLength);
+
+				SteamUtils()->GetEnteredGamepadTextInput(EnteredText.GetData(), BufferLength);
+
+				// convert to FString/FText
+				const FString TextString = UTF8_TO_TCHAR(EnteredText.GetData());
+				const FText Text = FText::FromString(TextString);
+				
+				// submit text to widget
+				CurrentTextEntryWidget->SetTextFromVirtualKeyboard(Text, ETextEntryType::TextEntryAccepted);
+			}
+			else
+			{
+				CurrentTextEntryWidget->SetTextFromVirtualKeyboard(CurrentTextEntryWidget->GetText(), ETextEntryType::TextEntryCanceled);		
+			}
+	
+			CurrentTextEntryWidget = nullptr;
+		}
+	});
+}
+#endif

Source/OnDeck/Private/Slate/SteamBigPictureTextField.cpp

@@ -0,0 +1,30 @@
+// Copyright Stephen Swires. All Rights Reserved.
+
+#pragma once
+
+#include "Framework/Application/IPlatformTextField.h"
+
+#if ONDECK_STEAM_API_AVAILABLE
+	#include "steam/steam_api_common.h"
+	#include "steam/isteamutils.h"
+#endif
+
+class IVirtualKeyboardEntry;
+
+class FSteamBigPictureTextField : public IPlatformTextField
+{
+public:
+	FSteamBigPictureTextField();
+	
+	virtual void ShowVirtualKeyboard(bool bShow, int32 UserIndex, TSharedPtr<IVirtualKeyboardEntry> TextEntryWidget);
+	virtual bool AllowMoveCursor() override;
+
+private:
+
+#if ONDECK_STEAM_API_AVAILABLE
+	STEAM_CALLBACK(FSteamBigPictureTextField, OnGamepadTextInputDismissed, GamepadTextInputDismissed_t, GamepadTextInputDismissed);
+#endif
+
+	TSharedPtr<IVirtualKeyboardEntry> CurrentTextEntryWidget;
+	
+};

Source/OnDeck/Private/Slate/SteamBigPictureTextField.h

@@ -0,0 +1,14 @@
+// Copyright Stephen Swires. All Rights Reserved.
+
+#include "Steam/OnDeckFunctionLibrary.h"
+#include "IOnDeckModule.h"
+
+bool UOnDeckFunctionLibrary::IsRunningOnSteamDeck()
+{
+	return IOnDeckModule::Get().IsRunningOnSteamDeck();
+}
+
+bool UOnDeckFunctionLibrary::IsRunningInSteamBigPicture()
+{
+	return IOnDeckModule::Get().IsRunningInSteamBigPicture();
+}

Source/OnDeck/Private/Steam/OnDeckFunctionLibrary.cpp

@@ -0,0 +1,3 @@
+// Copyright Stephen Swires. All Rights Reserved.
+
+#include "Steam/OnDeckSettings.h"