[UNR-2003] Create CookAndGenerateSchemaCommandlet

SpatialGDK/Source/SpatialGDK/Public/Utils/EngineVersionCheck.h

@@ -7,7 +7,7 @@
 // GDK Version to be updated with SPATIAL_ENGINE_VERSION
 // when breaking changes are made to the engine that requires
 // changes to the GDK to remain compatible
-#define SPATIAL_GDK_VERSION 6
+#define SPATIAL_GDK_VERSION 7
 
 // Check if GDK is compatible with the current version of Unreal Engine
 // SPATIAL_ENGINE_VERSION is incremented in engine when breaking changes

SpatialGDK/Source/SpatialGDKEditor/Private/SchemaGenerator/SchemaGenerator.cpp

@@ -12,6 +12,9 @@
 #include "Utils/CodeWriter.h"
 #include "Utils/ComponentIdGenerator.h"
 #include "Utils/DataTypeUtilities.h"
+#include "SpatialGDKEditorSchemaGenerator.h"
+
+using namespace SpatialGDKEditor::Schema;
 
 DEFINE_LOG_CATEGORY(LogSchemaGenerator);
 
@@ -565,7 +568,7 @@ void GenerateSubobjectSchemaForActorIncludes(FCodeWriter& Writer, TSharedPtr<FUn
 		{
 			UObject* Value = PropertyTypeInfo->Object;
 
-			if (Value != nullptr && !Value->IsEditorOnly())
+			if (Value != nullptr && IsSupportedClass(Value->GetClass()))
 			{
 				UClass* Class = Value->GetClass();
 				if (!AlreadyImported.Contains(Class) && SchemaGeneratedClasses.Contains(Class))

SpatialGDK/Source/SpatialGDKEditor/Private/SchemaGenerator/SpatialGDKEditorSchemaGenerator.cpp

@@ -57,7 +57,9 @@ const FString SchemaDatabasePackagePath = FPaths::Combine(FPaths::ProjectContent
 const FString SchemaDatabaseAssetPath = FPaths::SetExtension(SpatialConstants::SCHEMA_DATABASE_ASSET_PATH, TEXT(".SchemaDatabase"));
 const FString SchemaDatabaseFileName = FPaths::SetExtension(SchemaDatabasePackagePath, FPackageName::GetAssetPackageExtension());
 
-namespace
+namespace SpatialGDKEditor
+{
+namespace Schema
 {
 
 void AddPotentialNameCollision(const FString& DesiredSchemaName, const FString& ClassPath, const FString& GeneratedSchemaName)
@@ -240,8 +242,6 @@ bool ValidateIdentifierNames(TArray<TSharedPtr<FUnrealType>>& TypeInfos)
 	return bSuccess;
 }
 
-}// ::
-
 void GenerateSchemaFromClasses(const TArray<TSharedPtr<FUnrealType>>& TypeInfos, const FString& CombinedSchemaPath, FComponentIdGenerator& IdGenerator)
 {
 	// Generate the actual schema.
@@ -410,47 +410,90 @@ bool SaveSchemaDatabase()
 	return true;
 }
 
-TArray<UClass*> GetAllSupportedClasses()
+bool IsSupportedClass(UClass* SupportedClass)
 {
-	TSet<UClass*> Classes;
-	const TArray<FDirectoryPath>& DirectoriesToNeverCook = GetDefault<UProjectPackagingSettings>()->DirectoriesToNeverCook;
+	if (!IsValid(SupportedClass))
+	{
+		UE_LOG(LogSpatialGDKSchemaGenerator, Verbose, TEXT("[%s] Invalid Class not supported for schema gen."), *GetPathNameSafe(SupportedClass));
+		return false;
+	}
 
-	for (TObjectIterator<UClass> ClassIt; ClassIt; ++ClassIt)
+	if (SupportedClass->IsEditorOnly())
 	{
-		// User told us to ignore this class
-		if (ClassIt->HasAnySpatialClassFlags(SPATIALCLASS_NotSpatialType))
-		{
-			continue;
-		}
+		UE_LOG(LogSpatialGDKSchemaGenerator, Verbose, TEXT("[%s] Editor-only Class not supported for schema gen."), *GetPathNameSafe(SupportedClass));
+		return false;
+	}
 
-		UClass* SupportedClass = *ClassIt;
+	// User told us to ignore this class
+	if (SupportedClass->HasAnySpatialClassFlags(SPATIALCLASS_NotSpatialType))
+	{
+		UE_LOG(LogSpatialGDKSchemaGenerator, Verbose, TEXT("[%s] Not Spatial Type, not supported for schema gen."), *GetPathNameSafe(SupportedClass));
+		return false;
+	}
 
-		// Ensure we don't process transient generated classes for BP
-		if (SupportedClass->GetName().StartsWith(TEXT("SKEL_"), ESearchCase::CaseSensitive)
-			|| SupportedClass->GetName().StartsWith(TEXT("REINST_"), ESearchCase::CaseSensitive)
-			|| SupportedClass->GetName().StartsWith(TEXT("TRASHCLASS_"), ESearchCase::CaseSensitive)
-			|| SupportedClass->GetName().StartsWith(TEXT("HOTRELOADED_"), ESearchCase::CaseSensitive)
-			|| SupportedClass->GetName().StartsWith(TEXT("PROTO_BP_"), ESearchCase::CaseSensitive)
-			|| SupportedClass->GetName().StartsWith(TEXT("PLACEHOLDER-CLASS_"), ESearchCase::CaseSensitive)
-			|| SupportedClass->GetName().StartsWith(TEXT("ORPHANED_DATA_ONLY_"), ESearchCase::CaseSensitive))
+	if (!SupportedClass->HasAnySpatialClassFlags(SPATIALCLASS_ExplicitSpatialType))
+	{
+		// Check if parent class is supported, we need to do this because we have changed the defaults but Blueprint classes will
+		// not inherit these correctly if the files are locked by source control.
+		if (!IsSupportedClass(SupportedClass->GetSuperClass()))
 		{
-			continue;
+			UE_LOG(LogSpatialGDKSchemaGenerator, Verbose, TEXT("[%s] Not Explicit Spatial Type, parent not supported either, not supported for schema gen."), *GetPathNameSafe(SupportedClass));
+			return false;
 		}
+	}
 
-		// Avoid processing classes contained in Directories to Never Cook
-		const FString& ClassPath = SupportedClass->GetPathName();
-		if (DirectoriesToNeverCook.ContainsByPredicate([&ClassPath](const FDirectoryPath& Directory)
-		{
-			return ClassPath.StartsWith(Directory.Path);
-		}))
+	if (SupportedClass->HasAnyClassFlags(CLASS_LayoutChanging))
+	{
+		UE_LOG(LogSpatialGDKSchemaGenerator, Verbose, TEXT("[%s] Layout changing, not supported"), *GetPathNameSafe(SupportedClass));
+		return false;
+	}
+
+	// Ensure we don't process transient generated classes for BP
+	if (SupportedClass->GetName().StartsWith(TEXT("SKEL_"), ESearchCase::CaseSensitive)
+		|| SupportedClass->GetName().StartsWith(TEXT("REINST_"), ESearchCase::CaseSensitive)
+		|| SupportedClass->GetName().StartsWith(TEXT("TRASHCLASS_"), ESearchCase::CaseSensitive)
+		|| SupportedClass->GetName().StartsWith(TEXT("HOTRELOADED_"), ESearchCase::CaseSensitive)
+		|| SupportedClass->GetName().StartsWith(TEXT("PROTO_BP_"), ESearchCase::CaseSensitive)
+		|| SupportedClass->GetName().StartsWith(TEXT("PLACEHOLDER-CLASS_"), ESearchCase::CaseSensitive)
+		|| SupportedClass->GetName().StartsWith(TEXT("ORPHANED_DATA_ONLY_"), ESearchCase::CaseSensitive))
+	{
+		UE_LOG(LogSpatialGDKSchemaGenerator, Verbose, TEXT("[%s] Transient Class not supported for schema gen"), *GetPathNameSafe(SupportedClass));
+		return false;
+	}
+
+	const TArray<FDirectoryPath>& DirectoriesToNeverCook = GetDefault<UProjectPackagingSettings>()->DirectoriesToNeverCook;
+
+	// Avoid processing classes contained in Directories to Never Cook
+	const FString& ClassPath = SupportedClass->GetPathName();
+	if (DirectoriesToNeverCook.ContainsByPredicate([&ClassPath](const FDirectoryPath& Directory)
+	{
+		return ClassPath.StartsWith(Directory.Path);
+	}))
+	{
+		UE_LOG(LogSpatialGDKSchemaGenerator, Verbose, TEXT("[%s] Inside Directory to never cook for schema gen"), *GetPathNameSafe(SupportedClass));
+		return false;
+	}
+
+	UE_LOG(LogSpatialGDKSchemaGenerator, Verbose, TEXT("[%s] Supported Class"), *GetPathNameSafe(SupportedClass));
+	return true;
+}
+
+
+TSet<UClass*> GetAllSupportedClasses()
+{
+	TSet<UClass*> Classes;
+
+	for (TObjectIterator<UClass> ClassIt; ClassIt; ++ClassIt)
+	{
+		UClass* SupportedClass = *ClassIt;
+
+		if (IsSupportedClass(SupportedClass))
 		{
-			continue;
+			Classes.Add(SupportedClass);
 		}
-
-		Classes.Add(SupportedClass);
 	}
 
-	return Classes.Array();
+	return Classes;
 }
 
 void CopyWellKnownSchemaFiles()
@@ -560,7 +603,7 @@ bool TryLoadExistingSchemaDatabase()
 	return true;
 }
 
-SPATIALGDKEDITOR_API bool GeneratedSchemaFolderExists()
+bool GeneratedSchemaFolderExists()
 {
 	const FString SchemaOutputPath = GetDefault<USpatialGDKEditorSettings>()->GetGeneratedSchemaOutputFolder();
 	IPlatformFile& PlatformFile = FPlatformFileManager::Get().GetPlatformFile();
@@ -684,21 +727,65 @@ bool RunSchemaCompiler()
 	}
 }
 
-bool SpatialGDKGenerateSchema()
+bool SpatialGDKGenerateSchema(bool bSaveSchemaDatabase, bool bRunSchemaCompiler)
 {
-	ResetUsedNames();
+	// Generate Schema for classes loaded in memory.
+
+	if (!SpatialGDKGenerateSchemaForClasses(GetAllSupportedClasses()))
+	{
+		return false;
+	}
 
-	// Gets the classes currently loaded into memory.
-	SchemaGeneratedClasses = GetAllSupportedClasses();
-	SchemaGeneratedClasses.Sort();
+	if (bSaveSchemaDatabase)
+	{
+		if (!SaveSchemaDatabase())
+		{
+			return false;
+		}
+	}
 
+	if (bRunSchemaCompiler)
+	{
+		return RunSchemaCompiler();
+	}
+
+	return true;
+}
+
+bool SpatialGDKGenerateSchemaForClasses(TSet<UClass*> Classes)
+{
+	ResetUsedNames();
+	Classes.Sort([](const UClass& A, const UClass& B)
+	{
+		return A.GetPathName() < B.GetPathName();
+	});
+
 	// Generate Type Info structs for all classes
 	TArray<TSharedPtr<FUnrealType>> TypeInfos;
 
-	for (const auto& Class : SchemaGeneratedClasses)
+	for (const auto& Class : Classes)
 	{
+		if (SchemaGeneratedClasses.Contains(Class))
+		{
+			continue;
+		}
+
+		SchemaGeneratedClasses.Add(Class);
 		// Parent and static array index start at 0 for checksum calculations.
-		TypeInfos.Add(CreateUnrealTypeInfo(Class, 0, 0));
+		TSharedPtr<FUnrealType> TypeInfo = CreateUnrealTypeInfo(Class, 0, 0);
+		TypeInfos.Add(TypeInfo);
+		VisitAllObjects(TypeInfo, [&](TSharedPtr<FUnrealType> TypeNode)
+		{
+			if (UClass* NestedClass = Cast<UClass>(TypeNode->Type))
+			{
+				if (!Classes.Contains(NestedClass) && !SchemaGeneratedClasses.Contains(NestedClass) && IsSupportedClass(NestedClass))
+				{
+					TypeInfos.Add(CreateUnrealTypeInfo(NestedClass, 0, 0));
+					SchemaGeneratedClasses.Add(NestedClass);
+				}
+			}
+			return true;
+		});
 	}
 
 	if (!ValidateIdentifierNames(TypeInfos))
@@ -724,12 +811,11 @@ bool SpatialGDKGenerateSchema()
 	GenerateSchemaFromClasses(TypeInfos, SchemaOutputPath, IdGenerator);
 	GenerateSchemaForSublevels(SchemaOutputPath, IdGenerator);
 	NextAvailableComponentId = IdGenerator.Peek();
-	if (!SaveSchemaDatabase())
-	{
-		return false;
-	}
 
-	return RunSchemaCompiler();
+	return true;
 }
 
 #undef LOCTEXT_NAMESPACE
+
+} // Schema
+} // SpatialGDKEditor

SpatialGDK/Source/SpatialGDKEditor/Private/SchemaGenerator/TypeStructure.cpp

@@ -7,11 +7,7 @@
 #include "SpatialGDKEditorSchemaGenerator.h"
 #include "Utils/RepLayoutUtils.h"
 
-namespace Errors
-{
-	FString DuplicateComponentError = TEXT("WARNING: Unreal GDK does not currently support multiple static components of the same type.\n"
-		"Make sure {0} has only one instance of {1} or don't generate type bindings for {2}");
-}
+using namespace SpatialGDKEditor::Schema;
 
 TArray<EReplicatedPropertyGroup> GetAllReplicatedPropertyGroups()
 {
@@ -24,6 +20,19 @@ FString GetReplicatedPropertyGroupName(EReplicatedPropertyGroup Group)
 	return Group == REP_SingleClient ? TEXT("OwnerOnly") : TEXT("");
 }
 
+void VisitAllObjects(TSharedPtr<FUnrealType> TypeNode, TFunction<bool(TSharedPtr<FUnrealType>)> Visitor)
+{
+	bool bShouldRecurseFurther = Visitor(TypeNode);
+	for (auto& PropertyPair : TypeNode->Properties)
+	{
+		if (bShouldRecurseFurther && PropertyPair.Value->Type.IsValid())
+		{
+			// Recurse into subobjects.
+			VisitAllObjects(PropertyPair.Value->Type, Visitor);
+		}
+	}
+}
+
 void VisitAllProperties(TSharedPtr<FUnrealType> TypeNode, TFunction<bool(TSharedPtr<FUnrealProperty>)> Visitor)
 {
 	for (auto& PropertyPair : TypeNode->Properties)
@@ -465,7 +474,7 @@ FSubobjectMap GetAllSubobjects(TSharedPtr<FUnrealType> TypeInfo)
 		{
 			UObject* Value = PropertyTypeInfo->Object;
 
-			if (Value != nullptr && !Value->IsEditorOnly())
+			if (Value != nullptr && IsSupportedClass(Value->GetClass()))
 			{
 				if (!SeenComponents.Contains(Value))
 				{

SpatialGDK/Source/SpatialGDKEditor/Private/SchemaGenerator/TypeStructure.h

@@ -123,6 +123,11 @@ TArray<EReplicatedPropertyGroup> GetAllReplicatedPropertyGroups();
 // Convert a replicated property group to a string. Used to generate component names.
 FString GetReplicatedPropertyGroupName(EReplicatedPropertyGroup Group);
 
+// Given an AST, this applies the function 'Visitor' to all FUnrealType's contained transitively within the properties. bRecurseIntoObjects will control	
+// whether this function will recurse into a UObject's properties, which may not always be desirable. However, it will always recurse into substructs.	
+// If the Visitor function returns false, it will not recurse any further into that part of the tree.
+void VisitAllObjects(TSharedPtr<FUnrealType> TypeNode, TFunction<bool(TSharedPtr<FUnrealType>)> Visitor);
+
 // Given an AST, this applies the function 'Visitor' to all properties contained transitively within the type. This will recurse into substructs.
 // If the Visitor function returns false, it will not recurse any further into that part of the tree.
 void VisitAllProperties(TSharedPtr<FUnrealType> TypeNode, TFunction<bool(TSharedPtr<FUnrealProperty>)> Visitor);

SpatialGDK/Source/SpatialGDKEditor/Private/SchemaGenerator/Utils/CodeWriter.cpp

@@ -120,4 +120,4 @@ void FCodeWriter::WriteToFile(const FString& Filename)
 void FCodeWriter::Dump()
 {
 	UE_LOG(LogTemp, Warning, TEXT("%s"), *OutputSource);
-}
+}

SpatialGDK/Source/SpatialGDKEditor/Private/SpatialGDKEditor.cpp

@@ -18,6 +18,8 @@
 #include "UObject/StrongObjectPtr.h"
 #include "Settings/ProjectPackagingSettings.h"
 
+using namespace SpatialGDKEditor;
+
 DEFINE_LOG_CATEGORY(LogSpatialGDKEditor);
 
 #define LOCTEXT_NAMESPACE "FSpatialGDKEditor"
@@ -59,7 +61,7 @@ bool FSpatialGDKEditor::GenerateSchema(bool bFullScan)
 
 	RemoveEditorAssetLoadedCallback();
 
-	if (!TryLoadExistingSchemaDatabase())
+	if (!Schema::TryLoadExistingSchemaDatabase())
 	{
 		bSchemaGeneratorRunning = false;
 		return false;
@@ -89,12 +91,12 @@ bool FSpatialGDKEditor::GenerateSchema(bool bFullScan)
 	if (bFullScan)
 	{
 		// UNR-1610 - This copy is a workaround to enable schema_compiler usage until FPL is ready. Without this prepare_for_run checks crash local launch and cloud upload.
-		CopyWellKnownSchemaFiles();
-		DeleteGeneratedSchemaFiles();
+		Schema::CopyWellKnownSchemaFiles();
+		Schema::DeleteGeneratedSchemaFiles();
 	}
 
 	Progress.EnterProgressFrame(bFullScan ? 10.f : 100.f);
-	bool bResult = SpatialGDKGenerateSchema();
+	bool bResult = Schema::SpatialGDKGenerateSchema();
 
 	// We delay printing this error until after the schema spam to make it have a higher chance of being noticed.
 	if (ErroredBlueprints.Num() > 0)
@@ -248,7 +250,7 @@ void FSpatialGDKEditor::StopCloudDeployment(FSimpleDelegate SuccessCallback, FSi
 
 bool FSpatialGDKEditor::FullScanRequired()
 {
-	return !GeneratedSchemaFolderExists() || !GeneratedSchemaDatabaseExists();
+	return !Schema::GeneratedSchemaFolderExists() || !Schema::GeneratedSchemaDatabaseExists();
 }
 
 void FSpatialGDKEditor::RemoveEditorAssetLoadedCallback()