feat: manual custom runner and ecsact wasm api fns

Author: zaucy

Source/Ecsact/Ecsact.Build.cs

@@ -65,6 +65,7 @@ public Ecsact(ReadOnlyTargetRules Target) : base(Target) {
 			"ECSACT_META_API_LOAD_AT_RUNTIME",
 			"ECSACT_SERIALIZE_API_LOAD_AT_RUNTIME",
 			"ECSACT_STATIC_API_LOAD_AT_RUNTIME",
+			"ECSACTSI_WASM_API_LOAD_AT_RUNTIME",
 		});
 		PrivateDefinitions.AddRange(new string[] {
 			"ECSACT_CORE_API_EXPORT",
@@ -73,6 +74,7 @@ public Ecsact(ReadOnlyTargetRules Target) : base(Target) {
 			"ECSACT_META_API_EXPORT",
 			"ECSACT_SERIALIZE_API_EXPORT",
 			"ECSACT_STATIC_API_EXPORT",
+			"ECSACTSI_WASM_API_EXPORT",
 		});
 
 		var EcsactSources = GetEcsactSources();

Source/Ecsact/Private/EcsactGameInstanceSubsystem.cpp

@@ -126,3 +126,12 @@ auto UEcsactGameInstanceSubsystem::StopRunner() -> void {
 	runner->Stop();
 	Runner.Reset();
 }
+
+auto UEcsactGameInstanceSubsystem::CanStartCustomRunner() const -> bool {
+	const auto* settings = GetDefault<UEcsactSettings>();
+	if(settings->Runner == EEcsactRuntimeRunnerType::Custom) {
+		return !settings->CustomRunnerClass;
+	}
+
+	return false;
+}

Source/Ecsact/Private/EcsactGameInstanceSubsystem.h

@@ -1,12 +1,15 @@
 #pragma once
 
+#include "EcsactUnreal/Ecsact.h"
+#include "EcsactUnreal/EcsactRunner.h"
+#include "Engine/World.h"
 #include "Subsystems/GameInstanceSubsystem.h"
 #include "EcsactUnreal/RuntimeHandle.h"
 #include "EcsactGameInstanceSubsystem.generated.h"
 
 UCLASS()
 
-class UEcsactGameInstanceSubsystem : public UGameInstanceSubsystem {
+class ECSACT_API UEcsactGameInstanceSubsystem : public UGameInstanceSubsystem {
 	GENERATED_BODY() // NOLINT
 
 	friend class EcsactUnrealExecution;
@@ -29,4 +32,54 @@ class UEcsactGameInstanceSubsystem : public UGameInstanceSubsystem {
 public:
 	auto Initialize(FSubsystemCollectionBase& Collection) -> void override;
 	auto Deinitialize() -> void override;
+
+	/**
+	 * @returns true if runtime runner type is 'Custom' and the custom runner
+	 * class is `None`.
+	 */
+	auto CanStartCustomRunner() const -> bool;
+
+	/**
+	 * Instantiates and starts a custom runner of type @t RunnerT. May only be
+	 * called `CanStartCustomRunner()` returns `true.
+	 */
+	template<typename RunnerT>
+	auto StartCustomRunner() -> void {
+		if(Runner.IsValid()) {
+			UE_LOG(
+				Ecsact,
+				Error,
+				TEXT("An Ecsact runner has already started - only one runner may be "
+						 "running per game instance world.")
+			);
+			return;
+		}
+
+		auto world = GetWorld();
+		check(world);
+		if(!CanStartCustomRunner()) {
+			UE_LOG(
+				Ecsact,
+				Error,
+				TEXT("Cannot start custom ecsact runner - please make sure runner type "
+						 "is set to 'Custom' and the custom runner class is set to 'None' "
+						 "in the unreal Ecsact plugin settings.")
+			);
+			return;
+		}
+
+		Runner = NewObject<RunnerT>();
+
+		if(auto RunnerPtr = Runner.Get(); RunnerPtr) {
+			UE_LOG(
+				Ecsact,
+				Log,
+				TEXT("Starting custom ecsact runner: %s"),
+				*RunnerPtr->GetClass()->GetName()
+			);
+			RunnerPtr->World = world;
+			RunnerPtr->AddToRoot();
+			RunnerPtr->Start();
+		}
+	}
 };

Source/Ecsact/Public/EcsactUnreal/Ecsact.cpp

@@ -7,6 +7,7 @@
 #include "Misc/Paths.h"
 #include "EcsactUnreal/EcsactAsyncRunner.h"
 #include "ecsact/runtime.h"
+#include "ecsact/wasm.h"
 #include "Engine/World.h"
 
 #define LOCTEXT_NAMESPACE "FEcsactModule"
@@ -15,6 +16,7 @@ DEFINE_LOG_CATEGORY(Ecsact);
 
 #define INIT_ECSACT_API_FN(fn, UNUSED_PARAM) decltype(fn) fn = nullptr
 FOR_EACH_ECSACT_API_FN(INIT_ECSACT_API_FN, UNUSED_PARAM);
+FOR_EACH_ECSACTSI_WASM_API_FN(INIT_ECSACT_API_FN, UNUSED_PARAM);
 #undef INIT_ECSACT_API_FN
 
 FEcsactModule* FEcsactModule::Self = nullptr;

Source/Ecsact/Public/EcsactUnreal/Ecsact.h

@@ -6,7 +6,7 @@
 #include "UObject/WeakObjectPtr.h"
 #include "EcsactUnreal/RuntimeHandle.h"
 
-DECLARE_LOG_CATEGORY_EXTERN(Ecsact, Log, All);
+ECSACT_API DECLARE_LOG_CATEGORY_EXTERN(Ecsact, Log, All);
 
 namespace EcsactUnreal::Detail {
 auto CheckRuntimeNotLoaded(FEcsactModule&) -> bool;

Source/Ecsact/Public/EcsactUnreal/EcsactSyncRunner.cpp

@@ -26,24 +26,47 @@ auto UEcsactSyncRunner::Tick(float DeltaTime) -> void {
 	EcsactUnrealExecution::DeltaTime_ = DeltaTime;
 
 	if(registry_id == ECSACT_INVALID_ID(registry)) {
-		UE_LOG(
-			Ecsact,
-			Warning,
-			TEXT("UEcsactSyncRunner register_id is unset. Creating one for you. We "
-					 "recommend creating your own instead.")
-		);
-		registry_id = ecsact_create_registry("Default Registry");
+		if(ecsact_create_registry) {
+			UE_LOG(
+				Ecsact,
+				Warning,
+				TEXT("UEcsactSyncRunner register_id is unset. Creating one for you. We "
+						 "recommend creating your own instead.")
+			);
+			registry_id = ecsact_create_registry("Default Registry");
+		} else {
+			UE_LOG(
+				Ecsact,
+				Error,
+				TEXT("UEcsactSyncRunner registry_id is unset and "
+						 "ecsact_create_registry is unavailable - unable to automatically "
+						 "create an Ecsact registry")
+			);
+		}
 	}
 
-	ecsact_execution_options* exec_opts = nullptr;
-	if(ExecutionOptions != nullptr && ExecutionOptions->IsNotEmpty()) {
-		exec_opts = ExecutionOptions->GetCPtr();
-	}
+	if(registry_id != ECSACT_INVALID_ID(registry)) {
+		ecsact_execution_options* exec_opts = nullptr;
+		if(ExecutionOptions != nullptr && ExecutionOptions->IsNotEmpty()) {
+			exec_opts = ExecutionOptions->GetCPtr();
+		}
 
-	auto err =
-		ecsact_execute_systems(registry_id, 1, exec_opts, GetEventsCollector());
-	if(err != ECSACT_EXEC_SYS_OK) {
-		UE_LOG(Ecsact, Error, TEXT("Ecsact execution failed"));
+		if(ecsact_execute_systems) {
+			auto err =
+				ecsact_execute_systems(registry_id, 1, exec_opts, GetEventsCollector());
+			if(err != ECSACT_EXEC_SYS_OK) {
+				UE_LOG(Ecsact, Error, TEXT("Ecsact execution failed"));
+			}
+			if(ExecutionOptions) {
+				ExecutionOptions->Clear();
+			}
+		} else {
+			UE_LOG(
+				Ecsact,
+				Error,
+				TEXT("ecsact_execute_systems unavailable - unable to execute systems")
+			);
+		}
 	}
 }
 

Source/Ecsact/Public/EcsactUnreal/EcsactSyncRunner.h

@@ -11,6 +11,9 @@ UCLASS(NotBlueprintable)
 
 class ECSACT_API UEcsactSyncRunner : public UEcsactRunner {
 	GENERATED_BODY() // NOLINT
+
+	float LastTickTime = 0.f;
+
 protected:
 	auto StreamImpl(
 		ecsact_entity_id    Entity,

Source/Ecsact/Public/EcsactUnreal/RuntimeLoad.h

@@ -3,6 +3,7 @@
 #include "EcsactUnreal/Ecsact.h"
 #include "EcsactUnreal/RuntimeHandle.h"
 #include "ecsact/runtime.h"
+#include "ecsact/wasm.h"
 
 /** @internal - DO NOT USE */
 #define ECSACT_API_FN_INIT_(fn, UNUSED_PARAM) decltype(fn) fn = nullptr
@@ -20,12 +21,6 @@
 	}                                                                       \
 	static_assert(true, "require ;")
 
-/**
- * Call exactly once in your game modules .cpp file.
- */
-#define ECSACT_RUNTIME_INIT() \
-	FOR_EACH_ECSACT_API_FN(ECSACT_API_FN_INIT_, UNUSED_PARAM);
-
 // Check if we're using clangd on windows to shutup the traditional msvc error
 // TODO: https://github.com/ecsact-dev/ecsact_runtime/issues/267
 #if defined(__clang__) && defined(_WIN32)
@@ -70,6 +65,7 @@
 				return {};                                                         \
 			}                                                                    \
 			FOR_EACH_ECSACT_API_FN(ECSACTAPI_FN_FN_LOAD_);                       \
+			FOR_EACH_ECSACTSI_WASM_API_FN(ECSACTAPI_FN_FN_LOAD_);                \
 			return result;                                                       \
 		})()
 
@@ -84,6 +80,7 @@
 			}                                                             \
 			EcsactUnreal::Detail::UnloadPostDisconnect(module, Handle_);  \
 			FOR_EACH_ECSACT_API_FN(ECSACT_API_FN_RESET_);                 \
+			FOR_EACH_ECSACTSI_WASM_API_FN(ECSACT_API_FN_RESET_);          \
 			EcsactUnreal::Detail::UnloadPostReset(module, Handle_);       \
 		})(Handle)