/** Callback for creating a new level sequence asset in the level. */
static void OnCreateActorInLevel()
{
// Create a new level sequence
IAssetTools& AssetTools = FModuleManager::GetModuleChecked<FAssetToolsModule>("AssetTools").Get();
UObject* NewAsset = nullptr;
// Attempt to create a new asset
for (TObjectIterator<UClass> It ; It ; ++It)
{
UClass* CurrentClass = *It;
if (CurrentClass->IsChildOf(UFactory::StaticClass()) && !(CurrentClass->HasAnyClassFlags(CLASS_Abstract)))
{
UFactory* Factory = Cast<UFactory>(CurrentClass->GetDefaultObject());
if (Factory->CanCreateNew() && Factory->ImportPriority >= 0 && Factory->SupportedClass == ULevelSequence::StaticClass())
{
NewAsset = AssetTools.CreateAsset(ULevelSequence::StaticClass(), Factory);
break;
}
}
}
if (!NewAsset)
{
return;
}
// Spawn an actor at the origin, and either move infront of the camera or focus camera on it (depending on the viewport) and open for edit
UActorFactory* ActorFactory = GEditor->FindActorFactoryForActorClass(ALevelSequenceActor::StaticClass());
if (!ensure(ActorFactory))
{
return;
}
ALevelSequenceActor* NewActor = CastChecked<ALevelSequenceActor>(GEditor->UseActorFactory(ActorFactory, FAssetData(NewAsset), &FTransform::Identity));
if (GCurrentLevelEditingViewportClient != nullptr && GCurrentLevelEditingViewportClient->IsPerspective())
{
GEditor->MoveActorInFrontOfCamera(*NewActor, GCurrentLevelEditingViewportClient->GetViewLocation(), GCurrentLevelEditingViewportClient->GetViewRotation().Vector());
}
else
{
GEditor->MoveViewportCamerasToActor(*NewActor, false);
}
FAssetEditorManager::Get().OpenEditorForAsset(NewAsset);
}
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;
}
