[UNR-2003] Create CookAndGenerateSchemaCommandlet

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

@@ -12,6 +12,7 @@
 #include "Utils/CodeWriter.h"
 #include "Utils/ComponentIdGenerator.h"
 #include "Utils/DataTypeUtilities.h"
+#include "SpatialGDKEditorSchemaGenerator.h"
 
 DEFINE_LOG_CATEGORY(LogSchemaGenerator);
 
@@ -565,7 +566,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

@@ -410,47 +410,104 @@ 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())
+	{
+		UE_LOG(LogSpatialGDKSchemaGenerator, Verbose, TEXT("[%s] Editor-only Class Not supported for schema gen"), *GetPathNameSafe(SupportedClass));
+		return false;
+	}
+
+	// User told us to ignore this class
+	if (SupportedClass->HasAnySpatialClassFlags(SPATIALCLASS_NotSpatialType))
 	{
-		// User told us to ignore this class
-		if (ClassIt->HasAnySpatialClassFlags(SPATIALCLASS_NotSpatialType))
+		UE_LOG(LogSpatialGDKSchemaGenerator, Verbose, TEXT("[%s] Not Spatial Type, not supported for schema gen"), *GetPathNameSafe(SupportedClass));
+		return false;
+	}
+
+	if (!SupportedClass->HasAnySpatialClassFlags(SPATIALCLASS_ExplicitSpatialType))
+	{
+		// Check if parent class is supported.
+		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;
 		}
+	}
+
+	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;
 
-		// 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 (IsSupportedClass(SupportedClass))
 		{
-			continue;
+			Classes.Add(SupportedClass);
 		}
+	}
 
-		// 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);
-		}))
+	return Classes;
+}
+
+TSet<UClass*> FilterClasses(TSet<UClass*> Classes)
+{
+	TSet<UClass*> FilteredClasses;
+
+	for (auto Class : Classes)
+	{
+		if (IsSupportedClass(Class))
 		{
-			continue;
+			FilteredClasses.Add(Class);
 		}
-
-		Classes.Add(SupportedClass);
 	}
 
-	return Classes.Array();
+	return FilteredClasses;
 }
 
 void CopyWellKnownSchemaFiles()
@@ -684,21 +741,60 @@ bool RunSchemaCompiler()
 	}
 }
 
-bool SpatialGDKGenerateSchema()
+bool SpatialGDKGenerateSchema(bool bSaveSchemaDatabase, bool bRunSchemaCompiler)
 {
-	ResetUsedNames();
+	// Generate Schema for classes loaded in memory.
 
-	// Gets the classes currently loaded into memory.
-	SchemaGeneratedClasses = GetAllSupportedClasses();
-	SchemaGeneratedClasses.Sort();
+	if (!SpatialGDKGenerateSchemaForClasses(GetAllSupportedClasses()))
+	{
+		return false;
+	}
 
+	if (bSaveSchemaDatabase)
+	{
+		if (!SaveSchemaDatabase())
+		{
+			return false;
+		}
+	}
+
+	if (bRunSchemaCompiler)
+	{
+		return RunSchemaCompiler();
+	}
+
+	return true;
+}
+
+SPATIALGDKEDITOR_API bool SpatialGDKGenerateSchemaForClasses(TSet<UClass*> Classes)
+{
+	ResetUsedNames();
+	TSet<UClass*> NewClasses = FilterClasses(Classes);
+	TArray<UClass*> SortedClasses = NewClasses.Array();
+	SortedClasses.Sort();
+
 	// Generate Type Info structs for all classes
 	TArray<TSharedPtr<FUnrealType>> TypeInfos;
 
-	for (const auto& Class : SchemaGeneratedClasses)
+	for (const auto& Class : SortedClasses)
 	{
+		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 (!NewClasses.Contains(NestedClass) && !SchemaGeneratedClasses.Contains(NestedClass) && IsSupportedClass(NestedClass))
+				{
+					TypeInfos.Add(CreateUnrealTypeInfo(NestedClass, 0, 0));
+					SchemaGeneratedClasses.Add(NestedClass);
+				}
+			}
+			return true;
+		}, true);
 	}
 
 	if (!ValidateIdentifierNames(TypeInfos))
@@ -724,12 +820,8 @@ bool SpatialGDKGenerateSchema()
 	GenerateSchemaFromClasses(TypeInfos, SchemaOutputPath, IdGenerator);
 	GenerateSchemaForSublevels(SchemaOutputPath, IdGenerator);
 	NextAvailableComponentId = IdGenerator.Peek();
-	if (!SaveSchemaDatabase())
-	{
-		return false;
-	}
 
-	return RunSchemaCompiler();
+	return true;
 }
 
 #undef LOCTEXT_NAMESPACE

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

@@ -24,6 +24,22 @@ FString GetReplicatedPropertyGroupName(EReplicatedPropertyGroup Group)
 	return Group == REP_SingleClient ? TEXT("OwnerOnly") : TEXT("");
 }
 
+void VisitAllObjects(TSharedPtr<FUnrealType> TypeNode, TFunction<bool(TSharedPtr<FUnrealType>)> Visitor, bool bRecurseIntoSubobjects)
+{
+	bool bShouldRecurseFurther = Visitor(TypeNode);
+	for (auto& PropertyPair : TypeNode->Properties)
+	{
+		if (bShouldRecurseFurther && PropertyPair.Value->Type.IsValid())
+		{
+			// Either recurse into subobjects if they're structs or bRecurseIntoSubobjects is true.	
+			if (bRecurseIntoSubobjects || PropertyPair.Value->Property->IsA<UStructProperty>())
+			{
+				VisitAllObjects(PropertyPair.Value->Type, Visitor, bRecurseIntoSubobjects);
+			}
+		}
+	}
+}
+
 void VisitAllProperties(TSharedPtr<FUnrealType> TypeNode, TFunction<bool(TSharedPtr<FUnrealProperty>)> Visitor)
 {
 	for (auto& PropertyPair : TypeNode->Properties)
@@ -465,7 +481,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.	// 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, bool bRecurseIntoSubobjects);
+
 // 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/Public/SpatialGDKEditorSchemaGenerator.h

@@ -6,7 +6,13 @@
 
 DECLARE_LOG_CATEGORY_EXTERN(LogSpatialGDKSchemaGenerator, Log, All);
 
-SPATIALGDKEDITOR_API bool SpatialGDKGenerateSchema();
+SPATIALGDKEDITOR_API bool SpatialGDKGenerateSchema(bool bSaveSchemaDatabase = true, bool bRunSchemaCompiler = true);
+
+SPATIALGDKEDITOR_API bool SpatialGDKGenerateSchemaForClasses(TSet<UClass*> Classes);
+
+SPATIALGDKEDITOR_API bool SaveSchemaDatabase();
+
+SPATIALGDKEDITOR_API bool RunSchemaCompiler();
 
 SPATIALGDKEDITOR_API void ClearGeneratedSchema();
 
@@ -21,3 +27,5 @@ SPATIALGDKEDITOR_API bool GeneratedSchemaFolderExists();
 SPATIALGDKEDITOR_API bool DeleteSchemaDatabase();
 
 SPATIALGDKEDITOR_API bool GeneratedSchemaDatabaseExists();
+
+SPATIALGDKEDITOR_API bool IsSupportedClass(UClass* SupportedClass);