2.18.1908

* Call SetLogLevel during InitializeAsync to ensure it's set correctly in PIE
* Expose Percentage_Unsigned64 blueprint function for FModioUnsigned64
* Update NativeSDK

Doc/documentation.html

@@ -1336,7 +1336,6 @@ <h3 id="_plugin_quick_start_initialization_and_teardown">Plugin quick-start: Ini
 		GEngine-&gt;GetEngineSubsystem&lt;UModioSubsystem&gt;()-&gt;InitializeAsync(UModioSDKLibrary::GetProjectInitializeOptions(), FOnErrorOnlyDelegateFast::CreateUObject(this, &amp;UModioManager::OnInitCallback));
 	}
 
-
 	UE_LOG(LogModioGame, Log, TEXT("Initializing Modio SDK"));
 }
 
@@ -7070,7 +7069,7 @@ <h4 id="_values_20" class="discrete">Values</h4>
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2022-06-27 11:33:47 +1000
+Last updated 2022-07-01 14:12:33 +1000
 </div>
 </div>
 </body>

Doc/getting-started.adoc

@@ -172,7 +172,6 @@ void UModioManager::Init()
 		GEngine->GetEngineSubsystem<UModioSubsystem>()->InitializeAsync(UModioSDKLibrary::GetProjectInitializeOptions(), FOnErrorOnlyDelegateFast::CreateUObject(this, &UModioManager::OnInitCallback));
 	}
 	
-
 	UE_LOG(LogModioGame, Log, TEXT("Initializing Modio SDK"));
 }
 

Source/Modio/Private/Libraries/ModioCommonTypesLibrary.cpp

@@ -100,6 +100,12 @@ FModioInitializeOptions UModioCommonTypesLibrary::SetSessionIdentifier(const FMo
 	return DuplicateOptions;
 }
 
+
+int64 UModioCommonTypesLibrary::GetRawValueFromModID(const FModioModID& In) 
+{
+	return GetUnderlyingValue(In);
+}
+
 bool UModioCommonTypesLibrary::EqualTo(const FModioModID& A, const FModioModID& B)
 {
 	return A == B;

Source/Modio/Private/Libraries/ModioSDKLibrary.cpp

@@ -11,6 +11,7 @@
 #include "Libraries/ModioSDKLibrary.h"
 #include "Internationalization/Regex.h"
 #include "ModioSettings.h"
+#include "ModioTestSettings.h"
 
 FModioGameID UModioSDKLibrary::GetProjectGameId()
 {
@@ -43,7 +44,7 @@ FModioInitializeOptions UModioSDKLibrary::GetProjectInitializeOptions()
 FModioInitializeOptions UModioSDKLibrary::GetAutomationTestOptions()
 {
 	#if WITH_EDITORONLY_DATA
-	const UModioSettings* Settings = GetDefault<UModioSettings>();
+	const UModioTestSettings* Settings = GetDefault<UModioTestSettings>();
 	FModioInitializeOptions Options = Settings->AutomationTestOptions;
 	if (!Settings->AutomationSessionID.IsEmpty())
 	{

Source/Modio/Private/ModioSubsystem.cpp

@@ -70,6 +70,14 @@ bool UModioSubsystem::ShouldCreateSubsystem(UObject* Outer) const
 
 void UModioSubsystem::InitializeAsync(const FModioInitializeOptions& Options, FOnErrorOnlyDelegateFast OnInitComplete)
 {
+#if WITH_EDITOR
+	if (const UModioSettings* Settings = GetMutableDefault<UModioSettings>())
+	{
+		UE_LOG(LogModio, Display, TEXT("Setting log level to %d"), (int32) Settings->LogLevel);
+		SetLogLevel(Settings->LogLevel);
+	}
+#endif
+
 	Modio::InitializeAsync(ToModio(Options), [this, OnInitComplete](Modio::ErrorCode ec) {
 		InvalidateUserSubscriptionCache();
 

Source/Modio/Private/ModioTestSettings.cpp

@@ -0,0 +1,13 @@
+/*
+ *  Copyright (C) 2021 mod.io Pty Ltd. <https://mod.io>
+ *
+ *  This file is part of the mod.io UE4 Plugin.
+ *
+ *  Distributed under the MIT License. (See accompanying file LICENSE or
+ *   view online at <https://github.com/modio/modio-ue4/blob/main/LICENSE>)
+ *
+ */
+
+#include "ModioTestSettings.h"
+
+UModioTestSettings::UModioTestSettings() {}

Source/Modio/Public/Libraries/ModioCommonTypesLibrary.h

@@ -160,7 +160,14 @@ class MODIO_API UModioCommonTypesLibrary : public UBlueprintFunctionLibrary
 	UFUNCTION(BlueprintPure, Category = "mod.io|Utilities")
 	static FModioInitializeOptions SetSessionIdentifier(const FModioInitializeOptions& Options,
 														const FString& SessionIdentifier);
-
+	/**
+	 * @brief Retrieves the raw underlying value from a FModioModID. FModioModIDs are intended as opaque types, so use
+	 * with care.
+	 * @param In - the FModioModID to retrieve the value for
+	 * @return The underlying value 
+	 */
+	UFUNCTION(BlueprintPure, BlueprintCallable, Category = "mod.io|Utilities")
+	static int64 GetRawValueFromModID(const FModioModID& In);
 	/**
 	 * @brief Compares two ModioModIDs, returning true if equal
 	 */

Source/Modio/Public/ModioSettings.h

@@ -44,14 +44,6 @@ class MODIO_API UModioSettings : public UObject
 	UPROPERTY(EditDefaultsOnly, config, Category = "Project")
 	EModioPortal DefaultPortal = EModioPortal::None;
 
-#if WITH_EDITORONLY_DATA
-	UPROPERTY(EditDefaultsOnly, config, Category = "Project|Automation Testing")
-	FModioInitializeOptions AutomationTestOptions;
-
-	UPROPERTY(EditDefaultsOnly, config, Category = "Project|Automation Testing")
-	FString AutomationSessionID;
-#endif
-
 private:
 #if WITH_EDITOR
 	void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;

Source/Modio/Public/ModioTestSettings.h

@@ -0,0 +1,35 @@
+/*
+ *  Copyright (C) 2021 mod.io Pty Ltd. <https://mod.io>
+ *
+ *  This file is part of the mod.io UE4 Plugin.
+ *
+ *  Distributed under the MIT License. (See accompanying file LICENSE or
+ *   view online at <https://github.com/modio/modio-ue4/blob/main/LICENSE>)
+ *
+ */
+
+#pragma once
+
+#include "Types/ModioCommonTypes.h"
+#include "Types/ModioInitializeOptions.h"
+
+#include "ModioTestSettings.generated.h"
+
+/**
+ *
+ */
+UCLASS(Config = ModioTest, defaultconfig)
+class MODIO_API UModioTestSettings : public UObject
+{
+	GENERATED_BODY()
+public:
+	UModioTestSettings();
+
+#if WITH_EDITORONLY_DATA
+	UPROPERTY(EditDefaultsOnly, config, Category = "Automation Testing")
+	FModioInitializeOptions AutomationTestOptions;
+
+	UPROPERTY(EditDefaultsOnly, config, Category = "Automation Testing")
+	FString AutomationSessionID;
+#endif
+};

Source/Modio/Public/Types/ModioCommonTypes.h

@@ -193,6 +193,15 @@ struct MODIO_API FModioModID
 	}
 
 private:
+	/// @brief Function for retrieving the underlying value of an FModioModID for use in custom serialization. Not
+	/// recommended for any other use. FModioModIDs should be treated as opaque.
+	/// @param In the FModioModID to retrieve the value for
+	/// @return the underlying numeric ID.
+	MODIO_API friend int64 GetUnderlyingValue(const FModioModID& In)
+	{
+		return In.ModID;
+	}
+
 	friend struct Modio::ModID ToModio(const FModioModID& In);
 	int64 ModID;
 };

Source/Modio/Public/Types/ModioUnsigned64.h

@@ -98,6 +98,10 @@ struct MODIO_API FModioUnsigned64
 	{
 		return FModioUnsigned64(LHS.Underlying - RHS);
 	}
+	FORCEINLINE friend FModioUnsigned64 operator*(const FModioUnsigned64& LHS, const uint64 RHS)
+	{
+		return FModioUnsigned64(LHS.Underlying * RHS);
+	}
 
 	FORCEINLINE friend double operator/(const FModioUnsigned64& LHS, double Divisor)
 	{
@@ -170,19 +174,33 @@ class MODIO_API UModioUnsigned64Library : public UBlueprintFunctionLibrary
 	}
 
 	UFUNCTION(BlueprintPure, BlueprintCallable, Category = "mod.io|Unsigned64",
-			  meta = (CompactNodeTitle = "/", Keywords = "/ divide", DisplayName = "ModioUnsigned64 / ModioUnsigned64"))
+			  meta = (CompactNodeTitle = "/", Keywords = "/ divide",
+					  DisplayName = "ModioUnsigned64 / ModioUnsigned64 (truncate)"))
 	static FModioUnsigned64 Divide(const FModioUnsigned64& LHS, const FModioUnsigned64& RHS)
 	{
 		return LHS / RHS;
 	}
 
+	UFUNCTION(BlueprintPure, BlueprintCallable, Category = "mod.io|Unsigned64",
+			  meta = (CompactNodeTitle = "/", Keywords = "/ divide", DisplayName = "ModioUnsigned64 / ModioUnsigned64"))
+	static float DivideToFloat(const FModioUnsigned64& LHS, const FModioUnsigned64& RHS)
+	{
+		return (float) ((double) LHS / (double) RHS);
+	}
+
 	UFUNCTION(BlueprintPure, BlueprintCallable, Category = "mod.io|Unsigned64",
 			  meta = (CompactNodeTitle = "/", Keywords = "/ divide", DisplayName = "ModioUnsigned64 / float"))
 	static float DivideFloat(const FModioUnsigned64& LHS, const float RHS)
 	{
 		return (float) (LHS / (double) RHS);
 	}
 
+	UFUNCTION(BlueprintPure, BlueprintCallable, Category = "mod.io|Unsigned64")
+	static float Percentage_Unsigned64(const FModioUnsigned64& LHS, const FModioUnsigned64& RHS)
+	{
+		return DivideToFloat(LHS, RHS) * 100;
+	}
+
 	UFUNCTION(BlueprintPure, BlueprintCallable, Category = "mod.io|Unsigned64")
 	static void BreakToComponents(const FModioUnsigned64& In, int32& High, int32& Low)
 	{

Source/ModioTests/Private/ModioTestsModule.cpp

@@ -1,18 +1,46 @@
+#include "ModioTestsModule.h"
 #include "Core.h"
 #include "Engine/Engine.h"
-#include "ModioTestsModule.h"
 #include "PropertyEditorModule.h"
+#include "ModioTestSettings.h"
+
+#if WITH_EDITOR
+	#include "ISettingsModule.h"
+#endif
 
+#define LOCTEXT_NAMESPACE "FModioTestsModule"
 
 void FModioTestsModule::StartupModule()
 {
-
+	RegisterSettings();
 }
 
-
 void FModioTestsModule::ShutdownModule()
 {
+	UnregisterSettings();
 }
 
+void FModioTestsModule::RegisterSettings()
+{
+#if WITH_EDITOR
+	if (ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings"))
+	{
+		SettingsModule->RegisterSettings("Project", "Plugins", "mod.io unit tests", LOCTEXT("UnitTestsSettingsName", "mod.io unit tests"),
+										 LOCTEXT("UnitTestsSettingsDescription", "Configure the mod.io plugin unit tests"),
+										 GetMutableDefault<UModioTestSettings>());
+	}
+#endif
+}
+void FModioTestsModule::UnregisterSettings()
+{
+#if WITH_EDITOR 
+	if (ISettingsModule* SettingsModule = FModuleManager::GetModulePtr <ISettingsModule>("Settings"))
+	{
+		SettingsModule->UnregisterSettings("Project", "Plugins", "mod.io unit tests");
+	}
+#endif // WITH_EDITOR
+}
 
 IMPLEMENT_MODULE(FModioTestsModule, ModioTests)
+
+#undef LOCTEXT_NAMESPACE

Source/ModioTests/Private/ModioTestsModule.h

@@ -19,4 +19,7 @@ class FModioTestsModule : public IModuleInterface
 	virtual void StartupModule() override;
 	virtual void ShutdownModule() override;
 
+private:
+	void RegisterSettings();
+	void UnregisterSettings();
 };

Source/ModioTests/Private/Tests/ModioUnsigned64Tests.cpp

@@ -118,6 +118,22 @@ bool FModioUnsigned64OperatorAddTest::RunTest(const FString& Parameters)
 	return true;
 }
 
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(FModioUnsigned64ArithmeticPercentTest, "Modio.ModioUnsigned64.Arithmetic.Percent",
+								 EAutomationTestFlags::EditorContext | EAutomationTestFlags::ClientContext |
+									 EAutomationTestFlags::ProductFilter)
+
+bool FModioUnsigned64ArithmeticPercentTest::RunTest(const FString& Parameters)
+{
+	uint64 Value = 0xabcdF00d;
+	FModioUnsigned64 First = FModioUnsigned64(Value);
+	FModioUnsigned64 Second = First * 2;
+	float Result = UModioUnsigned64Library::Percentage_Unsigned64(First, Second);
+	TestEqual("ResultCorrect1", FMath::IsNearlyEqual(Result, 50.f), true);
+	Result = UModioUnsigned64Library::Percentage_Unsigned64(Second, First);
+	TestEqual("ResultCorrect2", FMath::IsNearlyEqual(Result, 200.f), true);
+	return true;
+}
+
 IMPLEMENT_SIMPLE_AUTOMATION_TEST(FModioUnsigned64MakeBreakComponentTest, "Modio.ModioUnsigned64.MakeBreak",
 								 EAutomationTestFlags::EditorContext | EAutomationTestFlags::ClientContext |
 									 EAutomationTestFlags::ProductFilter)