void UBehaviorTreeManager::DumpUsageStats() const
{
FNodeClassCounter AllNodesCounter;
for (TObjectIterator<UClass> It; It; ++It)
{
if (It->IsChildOf(UBTNode::StaticClass()) && It->HasAnyClassFlags(CLASS_Abstract) == false
#if WITH_EDITOR
&& !(FKismetEditorUtilities::IsClassABlueprintSkeleton(*It)
|| It->HasAnyClassFlags(CLASS_NewerVersionExists))
#endif
)
{
AllNodesCounter.Declare(*It);
}
}
UE_LOG(LogBehaviorTree, Display, TEXT("----------------------UBehaviorTreeManager::DumpUsageStats----------------------\nBehavior Trees:"));
// get all BTNode classes
for (TObjectIterator<UBehaviorTree> It; It; ++It)
{
FNodeClassCounter TreeNodeCounter;
UE_LOG(LogBehaviorTree, Display, TEXT("--- %s ---"), *(It->GetName()));
StatNodeUsage(It->RootNode, TreeNodeCounter);
TreeNodeCounter.Print();
AllNodesCounter.Append(TreeNodeCounter);
}
UE_LOG(LogBehaviorTree, Display, TEXT("--- Total Nodes usage:"));
AllNodesCounter.Print(TEXT(","));
}
void AssembleListOfExporters(TArray<UExporter*>& OutExporters)
{
auto TransientPackage = GetTransientPackage();
// @todo DB: Assemble this set once.
OutExporters.Empty();
for (TObjectIterator<UClass> It; It; ++It)
{
if (It->IsChildOf(UExporter::StaticClass()) && !It->HasAnyClassFlags(CLASS_Abstract))
{
UExporter* Exporter = NewObject<UExporter>(TransientPackage, *It);
OutExporters.Add(Exporter);
}
}
}
void NUTUtil::GetUnitTestClassDefList(TArray<UUnitTest*>& OutUnitTestClassDefaults)
{
for (TObjectIterator<UClass> It; It; ++It)
{
if (It->IsChildOf(UUnitTest::StaticClass()) && *It != UUnitTest::StaticClass() && *It != UClientUnitTest::StaticClass())
{
UUnitTest* CurDefault = Cast<UUnitTest>(It->GetDefaultObject());
if (CurDefault != NULL)
{
OutUnitTestClassDefaults.Add(CurDefault);
}
}
}
}
/**
* Initializes the list of possible level streaming methods.
* Does nothing if the lists are already initialized.
*/
void InitializeStreamingMethods()
{
check( GStreamingMethodStrings.Num() == GStreamingMethodClassList.Num() );
if ( GStreamingMethodClassList.Num() == 0 )
{
// Assemble a list of possible level streaming methods.
for ( TObjectIterator<UClass> It ; It ; ++It )
{
if ( It->IsChildOf( ULevelStreaming::StaticClass() ) &&
(It->HasAnyClassFlags(CLASS_EditInlineNew)) &&
!(It->HasAnyClassFlags(CLASS_Hidden | CLASS_Abstract | CLASS_Deprecated | CLASS_Transient)))
{
const FString ClassName( It->GetName() );
// Strip the leading "LevelStreaming" text from the class name.
// @todo DB: This assumes the names of all ULevelStreaming-derived types begin with the string "LevelStreaming".
GStreamingMethodStrings.Add( ClassName.Mid( 14 ) );
GStreamingMethodClassList.Add( *It );
}
}
}
}
UObject* UFactory::StaticImportObject
(
UClass* Class,
UObject* InOuter,
FName Name,
EObjectFlags Flags,
bool& bOutOperationCanceled,
const TCHAR* Filename,
UObject* Context,
UFactory* InFactory,
const TCHAR* Parms,
FFeedbackContext* Warn,
int32 MaxImportFileSize
)
{
check(Class);
CurrentFilename = Filename;
// Make list of all applicable factories.
TArray<UFactory*> Factories;
if( InFactory )
{
// Use just the specified factory.
if (ensureMsgf( !InFactory->SupportedClass || Class->IsChildOf(InFactory->SupportedClass),
TEXT("Factory is (%s), SupportedClass is (%s) and Class name is (%s)"), *InFactory->GetName(), (InFactory->SupportedClass)? *InFactory->SupportedClass->GetName() : TEXT("None"), *Class->GetName() ))
{
Factories.Add( InFactory );
}
}
else
{
auto TransientPackage = GetTransientPackage();
// Try all automatic factories, sorted by priority.
for( TObjectIterator<UClass> It; It; ++It )
{
if( It->IsChildOf( UFactory::StaticClass() ) )
{
UFactory* Default = It->GetDefaultObject<UFactory>();
if (Class->IsChildOf(Default->SupportedClass) && Default->ImportPriority >= 0)
{
Factories.Add(NewObject<UFactory>(TransientPackage, *It));
}
}
}
Factories.Sort([](const UFactory& A, const UFactory& B) -> bool
{
// First sort so that higher priorities are earlier in the list
if( A.ImportPriority > B.ImportPriority )
{
return true;
}
else if( A.ImportPriority < B.ImportPriority )
{
return false;
}
// Then sort so that factories that only create new assets are tried after those that actually import the file data (when they have an equivalent priority)
const bool bFactoryAImportsFiles = !A.CanCreateNew();
const bool bFactoryBImportsFiles = !B.CanCreateNew();
if( bFactoryAImportsFiles && !bFactoryBImportsFiles )
{
return true;
}
return false;
});
}
bool bLoadedFile = false;
// Try each factory in turn.
for( int32 i=0; i<Factories.Num(); i++ )
{
UFactory* Factory = Factories[i];
UObject* Result = NULL;
if( Factory->CanCreateNew() )
{
UE_LOG(LogFactory, Log, TEXT("FactoryCreateNew: %s with %s (%i %i %s)"), *Class->GetName(), *Factories[i]->GetClass()->GetName(), Factory->bCreateNew, Factory->bText, Filename );
Factory->ParseParms( Parms );
Result = Factory->FactoryCreateNew( Class, InOuter, Name, Flags, NULL, Warn );
}
else if( FCString::Stricmp(Filename,TEXT(""))!=0 )
{
if( Factory->bText )
{
//UE_LOG(LogFactory, Log, TEXT("FactoryCreateText: %s with %s (%i %i %s)"), *Class->GetName(), *Factories(i)->GetClass()->GetName(), Factory->bCreateNew, Factory->bText, Filename );
FString Data;
if( FFileHelper::LoadFileToString( Data, Filename ) )
{
bLoadedFile = true;
const TCHAR* Ptr = *Data;
Factory->ParseParms( Parms );
Result = Factory->FactoryCreateText( Class, InOuter, Name, Flags, NULL, *FPaths::GetExtension(Filename), Ptr, Ptr+Data.Len(), Warn );
}
}
else
{
UE_LOG(LogFactory, Log, TEXT("FactoryCreateBinary: %s with %s (%i %i %s)"), *Class->GetName(), *Factories[i]->GetClass()->GetName(), Factory->bCreateNew, Factory->bText, Filename );
// Sanity check the file size of the impending import and prompt the user if they wish to continue if the file size is very large
const int32 FileSize = IFileManager::Get().FileSize( Filename );
bool bValidFileSize = true;
if ( FileSize == INDEX_NONE )
{
UE_LOG(LogFactory, Error,TEXT("File '%s' does not exist"), Filename );
bValidFileSize = false;
}
TArray<uint8> Data;
if( bValidFileSize && FFileHelper::LoadFileToArray( Data, Filename ) )
{
bLoadedFile = true;
Data.Add( 0 );
const uint8* Ptr = &Data[ 0 ];
Factory->ParseParms( Parms );
Result = Factory->FactoryCreateBinary( Class, InOuter, Name, Flags, NULL, *FPaths::GetExtension(Filename), Ptr, Ptr+Data.Num()-1, Warn, bOutOperationCanceled );
}
}
}
if( Result )
{
// prevent UTextureCube created from UTextureFactory check(Result->IsA(Class));
Result->MarkPackageDirty();
ULevel::LevelDirtiedEvent.Broadcast();
Result->PostEditChange();
CurrentFilename = TEXT("");
return Result;
}
}
if ( !bLoadedFile && !bOutOperationCanceled )
{
Warn->Logf( *FText::Format( NSLOCTEXT( "UnrealEd", "NoFindImport", "Can't find file '{0}' for import" ), FText::FromString( FString(Filename) ) ).ToString() );
}
CurrentFilename = TEXT("");
return NULL;
}
