feat: using ecsact stream api

Author: zaucy

Source/Ecsact/Ecsact.Build.cs

@@ -66,6 +66,14 @@ public Ecsact(ReadOnlyTargetRules Target) : base(Target) {
 			"ECSACT_SERIALIZE_API_LOAD_AT_RUNTIME",
 			"ECSACT_STATIC_API_LOAD_AT_RUNTIME",
 		});
+		PrivateDefinitions.AddRange(new string[] {
+			"ECSACT_CORE_API_EXPORT",
+			"ECSACT_DYNAMIC_API_EXPORT",
+			"ECSACT_ASYNC_API_EXPORT",
+			"ECSACT_META_API_EXPORT",
+			"ECSACT_SERIALIZE_API_EXPORT",
+			"ECSACT_STATIC_API_EXPORT",
+		});
 
 		var EcsactSources = GetEcsactSources();
 
@@ -74,9 +82,9 @@ public Ecsact(ReadOnlyTargetRules Target) : base(Target) {
 				"codegen",
 				"--format=json",
 				"--plugin=cpp_header",
-				"--plugin=systems_header",
-				"--plugin=cpp_systems_header",
-				"--plugin=cpp_systems_source"
+				// "--plugin=systems_header",
+				// "--plugin=cpp_systems_header",
+				// "--plugin=cpp_systems_source"
 			};
 
 			if(!File.Exists(EcsactUnrealCodegenPluginPath)) {

Source/Ecsact/Public/EcsactUnreal/EcsactAsyncRunner.cpp

@@ -21,6 +21,22 @@ auto UEcsactAsyncRunner::StreamImpl(
 	ecsact_component_id ComponentId,
 	const void*         ComponentData
 ) -> void {
+#if WITH_EDITORONLY_DATA
+	if(ecsact_async_stream == nullptr) {
+		static bool notified_log = false;
+		if(!notified_log) {
+			notified_log = true;
+			UE_LOG(
+				Ecsact,
+				Error,
+				TEXT("ecsact_async_stream unavailable - cannot use "
+						 "UEcsactRunner::Stream")
+			);
+		}
+		return;
+	}
+#endif
+
 	ecsact_async_stream(Entity, ComponentId, ComponentData);
 }
 
@@ -92,22 +108,13 @@ auto UEcsactAsyncRunner::OnAsyncRequestDoneRaw(
 					UE_LOG(
 						Ecsact,
 						Warning,
-						TEXT("Unbound async done callback for request %i (self=%i)"),
-						req_id,
-						(intptr_t)self
+						TEXT("Unbound async done callback for request %i"),
+						req_id
 					);
 				}
 			}
 
 			cbs->Empty();
-		} else {
-			UE_LOG(
-				Ecsact,
-				Warning,
-				TEXT("No async done callbacks for request %i (self=%i)"),
-				req_id,
-				(intptr_t)self
-			);
 		}
 	}
 }
@@ -142,6 +149,8 @@ auto UEcsactAsyncRunner::EnqueueExecutionOptions() -> void {
 	if(ExecutionOptions->IsNotEmpty()) {
 		auto req_id =
 			ecsact_async_enqueue_execution_options(*ExecutionOptions->GetCPtr());
+		// UE_LOG(Ecsact, Warning, TEXT("SENDING STUFF! req_id=%i"), req_id);
+		// ExecutionOptions->DebugLog();
 		ExecutionOptions->Clear();
 	}
 }

Source/Ecsact/Public/EcsactUnreal/EcsactRunner.cpp

@@ -59,6 +59,18 @@ auto UEcsactRunner::IsTickable() const -> bool {
 	return !IsTemplate() && !bIsStopped;
 }
 
+auto UEcsactRunner::GetSubsystem( //
+	UClass* SubsystemClass
+) -> UEcsactRunnerSubsystem* {
+	for(auto* subsystem : RunnerSubsystems) {
+		if(subsystem->IsA(SubsystemClass)) {
+			return subsystem;
+		}
+	}
+
+	return nullptr;
+}
+
 auto UEcsactRunner::CreateEntity() -> EcsactRunnerCreateEntityBuilder {
 	return {this, GeneratePlaceholderId()};
 }
@@ -84,10 +96,6 @@ auto UEcsactRunner::InitRunnerSubsystems() -> void {
 			continue;
 		}
 
-		if(uclass->HasAnyFlags(RF_Transient)) {
-			continue;
-		}
-
 		subsystem_types.Add(uclass);
 	}
 
@@ -97,6 +105,7 @@ auto UEcsactRunner::InitRunnerSubsystems() -> void {
 	for(auto t : subsystem_types) {
 		UE_LOG(Ecsact, Log, TEXT("Starting ecsact subsystem %s"), *t->GetName());
 		auto subsystem = NewObject<UEcsactRunnerSubsystem>(this, t);
+		subsystem->OwningRunner = this;
 		subsystem->AddToRoot();
 		RunnerSubsystems.Add(subsystem);
 	}
@@ -173,6 +182,13 @@ auto UEcsactRunner::OnEntityCreatedRaw(
 	if(create_callback) {
 		create_callback->Execute(entity_id);
 		self->CreateEntityCallbacks.Remove(placeholder_entity_id);
+	} else {
+		UE_LOG(
+			Ecsact,
+			Error,
+			TEXT("Unable to find create entity callback for placeholder %i"),
+			(int32)placeholder_entity_id
+		);
 	}
 
 	for(auto subsystem : self->RunnerSubsystems) {

Source/Ecsact/Public/EcsactUnreal/EcsactRunner.h

@@ -85,6 +85,15 @@ class ECSACT_API UEcsactRunner : public UObject, public FTickableGameObject {
 	auto GetStatId() const -> TStatId override;
 	auto IsTickable() const -> bool override;
 
+	auto GetSubsystem(UClass* SubsystemClass) -> class UEcsactRunnerSubsystem*;
+
+	template<typename RunnerSubsystemT>
+	auto GetSubsystem() -> RunnerSubsystemT* {
+		return Cast<RunnerSubsystemT>( //
+			GetSubsystem(RunnerSubsystemT::StaticClass())
+		);
+	}
+
 	template<typename C>
 	auto Stream(ecsact_entity_id Entity, const C& StreamComponent) -> void {
 		return StreamImpl(Entity, C::id, &StreamComponent);
@@ -139,8 +148,9 @@ class ECSACT_API UEcsactRunner::EcsactRunnerCreateEntityBuilder {
 	auto AddComponent( //
 		const C& Component
 	) && -> EcsactRunnerCreateEntityBuilder {
-		static_cast<UEcsactUnrealExecutionOptions::CreateEntityBuilder&&>(Builder)
-			.AddComponent<C>(Component);
+		using CreateEntityBuilder =
+			UEcsactUnrealExecutionOptions::CreateEntityBuilder;
+		Builder = std::move(Builder).AddComponent<C>(Component);
 		return std::move(*this);
 	}
 

Source/Ecsact/Public/EcsactUnreal/EcsactRunnerSubsystem.cpp

@@ -21,6 +21,14 @@ auto UEcsactRunnerSubsystem::RemoveComponentRaw(
 ) -> void {
 }
 
+auto UEcsactRunnerSubsystem::GetRunner() -> class UEcsactRunner* {
+	return OwningRunner;
+}
+
+auto UEcsactRunnerSubsystem::GetRunner() const -> const class UEcsactRunner* {
+	return OwningRunner;
+}
+
 auto UEcsactRunnerSubsystem::RunnerStart_Implementation(
 	class UEcsactRunner* Runner
 ) -> void {

Source/Ecsact/Public/EcsactUnreal/EcsactRunnerSubsystem.h

@@ -9,6 +9,7 @@ class ECSACT_API UEcsactRunnerSubsystem : public UObject {
 	GENERATED_BODY() // NOLINT
 
 	friend class UEcsactRunner;
+	class UEcsactRunner* OwningRunner;
 
 protected:
 	virtual void InitComponentRaw(
@@ -27,6 +28,9 @@ class ECSACT_API UEcsactRunnerSubsystem : public UObject {
 		const void*         ComponentData
 	);
 
+	auto GetRunner() -> class UEcsactRunner*;
+	auto GetRunner() const -> const class UEcsactRunner*;
+
 public:
 	UFUNCTION(BlueprintNativeEvent, Category = "Ecsact Runner")
 	void RunnerStart(class UEcsactRunner* Runner);

Source/Ecsact/Public/EcsactUnreal/EcsactUnrealExecutionOptions.cpp

@@ -1,4 +1,5 @@
 #include "EcsactUnreal/EcsactUnrealExecutionOptions.h"
+#include "EcsactUnreal/Ecsact.h"
 #include "ecsact/runtime/common.h"
 
 using CreateEntityBuilder = UEcsactUnrealExecutionOptions::CreateEntityBuilder;
@@ -41,6 +42,54 @@ auto UEcsactUnrealExecutionOptions::Clear() -> void {
 	ExecOpts = {};
 }
 
+#ifdef WITH_EDITORONLY_DATA
+auto UEcsactUnrealExecutionOptions::DebugLog() const -> void {
+	if(!IsNotEmpty()) {
+		UE_LOG(Ecsact, Warning, TEXT("(Empty Ecsact Execution Options)"));
+		return;
+	}
+
+	UE_LOG(Ecsact, Log, TEXT(" == Ecsact Execution Options =="));
+	UE_LOG(Ecsact, Log, TEXT("\tActions Length: %i"), ExecOpts.actions_length);
+	for(auto i = 0; ExecOpts.actions_length > i; ++i) {
+		UE_LOG(
+			Ecsact,
+			Log,
+			TEXT("\t\tActionId: %i"),
+			ExecOpts.actions[i].action_id
+		);
+	}
+	UE_LOG(
+		Ecsact,
+		Log,
+		TEXT("\tCreate Entities Length: %i"),
+		ExecOpts.create_entities_length
+	);
+	for(auto i = 0; ExecOpts.create_entities_length > i; ++i) {
+		UE_LOG(
+			Ecsact,
+			Log,
+			TEXT("\t\tPlaceholderId: %i"),
+			ExecOpts.create_entities[i]
+		);
+		for(auto ci = 0; ExecOpts.create_entities_components_length[i] > ci; ++ci) {
+			auto comp_count = ExecOpts.create_entities_components_length[i];
+			auto comps = ExecOpts.create_entities_components[ci];
+			UE_LOG(
+				Ecsact,
+				Log,
+				TEXT("\t\tCreate Entity Component Count: %i"),
+				comp_count
+			);
+			for(auto cci = 0; cci > comp_count; ++cci) {
+				auto comp = comps[cci];
+				UE_LOG(Ecsact, Log, TEXT("\t\t\tComponentId: %i"), comp.component_id);
+			}
+		}
+	}
+}
+#endif
+
 auto UEcsactUnrealExecutionOptions::CreateEntity(
 	ecsact_placeholder_entity_id PlaceholderId
 ) -> CreateEntityBuilder {
@@ -49,29 +98,50 @@ auto UEcsactUnrealExecutionOptions::CreateEntity(
 
 CreateEntityBuilder::CreateEntityBuilder(
 	UEcsactUnrealExecutionOptions* Owner,
-	ecsact_placeholder_entity_id   PlacerholderId
+	ecsact_placeholder_entity_id   PlaceholderId
 )
 	: bValid(true), Owner(Owner), PlaceholderId(PlaceholderId) {
 }
 
 CreateEntityBuilder::CreateEntityBuilder(CreateEntityBuilder&& Other) {
 	bValid = Other.bValid;
 	Owner = Other.Owner;
+	PlaceholderId = Other.PlaceholderId;
 	ComponentList = std::move(Other.ComponentList);
 
 	Other.bValid = false;
 	Other.Owner = nullptr;
+	Other.PlaceholderId = {};
 	Other.ComponentList = {};
 }
 
+auto CreateEntityBuilder::operator=(CreateEntityBuilder&& Other
+) -> CreateEntityBuilder& {
+	bValid = Other.bValid;
+	Owner = Other.Owner;
+	PlaceholderId = Other.PlaceholderId;
+	ComponentList = std::move(Other.ComponentList);
+
+	Other.bValid = false;
+	Other.Owner = nullptr;
+	Other.PlaceholderId = {};
+	Other.ComponentList = {};
+	return *this;
+}
+
 CreateEntityBuilder::~CreateEntityBuilder() {
-	if(bValid && Owner) {
+	if(bValid) {
 		Finish();
 	}
 }
 
 auto CreateEntityBuilder::Finish() -> void {
-	if(!bValid || !Owner) {
+	if(!bValid) {
+		return;
+	}
+
+	if(!Owner) {
+		UE_LOG(Ecsact, Error, TEXT("Cannot create entity - Runner not valid"));
 		return;
 	}
 

Source/Ecsact/Public/EcsactUnreal/EcsactUnrealExecutionOptions.h

@@ -34,6 +34,10 @@ class ECSACT_API UEcsactUnrealExecutionOptions : public UObject {
 	auto Clear() -> void;
 	auto IsNotEmpty() const -> bool;
 
+#ifdef WITH_EDITORONLY_DATA
+	auto DebugLog() const -> void;
+#endif
+
 	/**
 	 * Get's the C `ecsact_execution_options` pointer typically passed to
 	 * `ecsact_execute_systems` or `ecsact_async_enqueue_execution_options`. The
@@ -118,6 +122,8 @@ class ECSACT_API UEcsactUnrealExecutionOptions::CreateEntityBuilder {
 	CreateEntityBuilder(CreateEntityBuilder&&);
 	~CreateEntityBuilder();
 
+	auto operator=(CreateEntityBuilder&&) -> CreateEntityBuilder&;
+
 	template<typename C>
 	auto AddComponent(const C& Component) && -> CreateEntityBuilder {
 		auto component_data = FMemory::Malloc(sizeof(C));

Source/EcsactEditor/Private/EcsactEditor.cpp

@@ -449,6 +449,7 @@ auto FEcsactEditorModule::RunBuild() -> void {
 		"-o",
 		ecsact_runtime_path,
 		"--temp=" + temp_dir,
+		"--debug",
 	};
 
 	switch(settings->BuildReportFilter) {