UObject* FTransaction::FObjectRecord::FPersistentObjectRef::Get() const
{
if (ReferenceType == EReferenceType::SubObject)
{
check (SubObjectHierarchyID.Num() > 0)
// find the subobject:
UObject* CurrentObject = Object;
bool bFoundTargetSubObject = (SubObjectHierarchyID.Num() == 0);
if (!bFoundTargetSubObject)
{
// Current increasing depth into sub-objects, starts at 1 to avoid the sub-object found and placed in NextObject.
int SubObjectDepth = SubObjectHierarchyID.Num() - 1;
UObject* NextObject = CurrentObject;
while (NextObject != nullptr && !bFoundTargetSubObject)
{
// Look for any UObject with the CurrentObject's outer to find the next sub-object:
NextObject = StaticFindObjectFast(UObject::StaticClass(), CurrentObject, SubObjectHierarchyID[SubObjectDepth]);
bFoundTargetSubObject = SubObjectDepth == 0;
--SubObjectDepth;
CurrentObject = NextObject;
}
}
return bFoundTargetSubObject ? CurrentObject : nullptr;
}
return Object;
}
FString UTimelineTemplate::MakeUniqueCurveName(UObject* Obj, UObject* InOuter)
{
FString OriginalName = Obj->GetName();
FName TestName(*OriginalName);
while(StaticFindObjectFast(NULL, InOuter, TestName))
{
TestName = FName(*OriginalName, TestName.GetNumber()+1);
}
return TestName.ToString();
}
FString UTimelineTemplate::MakeUniqueCurveName(UObject* Obj)
{
FString OriginalName = Obj->GetName();
UClass* Class = Obj->GetClass();
UObject* Outer = Obj->GetOuter();
FName TestName(*OriginalName);
while(StaticFindObjectFast(Class, Outer, TestName))
{
TestName = FName(*OriginalName, TestName.GetNumber()+1);
}
return TestName.ToString();
}
UPackage* Z_Construct_UPackage_ProjectErwin()
{
static UPackage* ReturnPackage = NULL;
if (!ReturnPackage)
{
ReturnPackage = CastChecked<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), NULL, FName(TEXT("/Script/ProjectErwin")), false, false));
ReturnPackage->PackageFlags |= PKG_CompiledIn | 0x00000000;
FGuid Guid;
Guid.A = 0x1055D45A;
Guid.B = 0x72F6A395;
Guid.C = 0x00000000;
Guid.D = 0x00000000;
ReturnPackage->SetGuid(Guid);
}
return ReturnPackage;
}
UPackage* Z_Construct_UPackage_SummerProject2015()
{
static UPackage* ReturnPackage = NULL;
if (!ReturnPackage)
{
ReturnPackage = CastChecked<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), NULL, FName(TEXT("/Script/SummerProject2015")), false, false));
ReturnPackage->PackageFlags |= PKG_CompiledIn | 0x00000000;
FGuid Guid;
Guid.A = 0x0EA07BE1;
Guid.B = 0x72C3FF08;
Guid.C = 0x00000000;
Guid.D = 0x00000000;
ReturnPackage->SetGuid(Guid);
}
return ReturnPackage;
}
UPackage* Z_Construct_UPackage_FPSProject()
{
static UPackage* ReturnPackage = NULL;
if (!ReturnPackage)
{
ReturnPackage = CastChecked<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), NULL, FName(TEXT("/Script/FPSProject")), false, false));
ReturnPackage->PackageFlags |= PKG_CompiledIn | 0x00000000;
FGuid Guid;
Guid.A = 0x91C0AFC9;
Guid.B = 0x0DF6EEB9;
Guid.C = 0x00000000;
Guid.D = 0x00000000;
ReturnPackage->SetGuid(Guid);
}
return ReturnPackage;
}
UPackage* Z_Construct_UPackage_SAMChess_test3()
{
static UPackage* ReturnPackage = NULL;
if (!ReturnPackage)
{
ReturnPackage = CastChecked<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), NULL, FName(TEXT("/Script/SAMChess_test3")), false, false));
ReturnPackage->SetPackageFlags(PKG_CompiledIn | 0x00000000);
FGuid Guid;
Guid.A = 0x940F4AA9;
Guid.B = 0x6562BF5D;
Guid.C = 0x00000000;
Guid.D = 0x00000000;
ReturnPackage->SetGuid(Guid);
}
return ReturnPackage;
}
UPackage* Z_Construct_UPackage_BatteryCollector()
{
static UPackage* ReturnPackage = NULL;
if (!ReturnPackage)
{
ReturnPackage = CastChecked<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), NULL, FName(TEXT("/Script/BatteryCollector")), false, false));
ReturnPackage->PackageFlags |= PKG_CompiledIn | 0x00000000;
FGuid Guid;
Guid.A = 0x467E87BC;
Guid.B = 0xE1ECE7D7;
Guid.C = 0x00000000;
Guid.D = 0x00000000;
ReturnPackage->SetGuid(Guid);
}
return ReturnPackage;
}
UPackage* Z_Construct_UPackage_TheBeginning()
{
static UPackage* ReturnPackage = NULL;
if (!ReturnPackage)
{
ReturnPackage = CastChecked<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), NULL, FName(TEXT("/Script/TheBeginning")), false, false));
ReturnPackage->PackageFlags |= PKG_CompiledIn | 0x00000000;
FGuid Guid;
Guid.A = 0xAF7F2495;
Guid.B = 0x2BE2AF11;
Guid.C = 0x00000000;
Guid.D = 0x00000000;
ReturnPackage->SetGuid(Guid);
}
return ReturnPackage;
}
UPackage* Z_Construct_UPackage_Puzzle2()
{
static UPackage* ReturnPackage = NULL;
if (!ReturnPackage)
{
ReturnPackage = CastChecked<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), NULL, FName(TEXT("/Script/Puzzle2")), false, false));
ReturnPackage->PackageFlags |= PKG_CompiledIn | 0x00000000;
FGuid Guid;
Guid.A = 0xF27671D0;
Guid.B = 0xA8FAFD40;
Guid.C = 0x00000000;
Guid.D = 0x00000000;
ReturnPackage->SetGuid(Guid);
}
return ReturnPackage;
}
UPackage* Z_Construct_UPackage__Script_ProjectS()
{
static UPackage* ReturnPackage = NULL;
if (!ReturnPackage)
{
ReturnPackage = CastChecked<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), NULL, FName(TEXT("/Script/ProjectS")), false, false));
ReturnPackage->SetPackageFlags(PKG_CompiledIn | 0x00000000);
FGuid Guid;
Guid.A = 0x5B7F4016;
Guid.B = 0x0AEDE04E;
Guid.C = 0x00000000;
Guid.D = 0x00000000;
ReturnPackage->SetGuid(Guid);
}
return ReturnPackage;
}
UPackage* Z_Construct_UPackage_GAME2013()
{
static UPackage* ReturnPackage = NULL;
if (!ReturnPackage)
{
ReturnPackage = CastChecked<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), NULL, FName(TEXT("/Script/GAME2013")), false, false));
ReturnPackage->PackageFlags |= PKG_CompiledIn | 0x00000000;
FGuid Guid;
Guid.A = 0x1D1E4298;
Guid.B = 0x7518B643;
Guid.C = 0x00000000;
Guid.D = 0x00000000;
ReturnPackage->SetGuid(Guid);
}
return ReturnPackage;
}
UPackage* Z_Construct_UPackage__Script_ArenaShooter()
{
static UPackage* ReturnPackage = NULL;
if (!ReturnPackage)
{
ReturnPackage = CastChecked<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), NULL, FName(TEXT("/Script/ArenaShooter")), false, false));
ReturnPackage->SetPackageFlags(PKG_CompiledIn | 0x00000000);
FGuid Guid;
Guid.A = 0x82E2E810;
Guid.B = 0xEFFAF111;
Guid.C = 0x00000000;
Guid.D = 0x00000000;
ReturnPackage->SetGuid(Guid);
Z_Construct_UDelegateFunction_ArenaShooter_SpawnDelegate__DelegateSignature();
}
return ReturnPackage;
}
UPackage* Z_Construct_UPackage__Script_SocketIOClient()
{
static UPackage* ReturnPackage = NULL;
if (!ReturnPackage)
{
ReturnPackage = CastChecked<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), NULL, FName(TEXT("/Script/SocketIOClient")), false, false));
ReturnPackage->SetPackageFlags(PKG_CompiledIn | 0x00000000);
FGuid Guid;
Guid.A = 0x754F3544;
Guid.B = 0x83CF0624;
Guid.C = 0x00000000;
Guid.D = 0x00000000;
ReturnPackage->SetGuid(Guid);
Z_Construct_UDelegateFunction_SocketIOClient_SIOCOnEventSignature__DelegateSignature();
}
return ReturnPackage;
}
void UWorldComposition::OnTileInfoUpdated(const FName& InPackageName, const FWorldTileInfo& InInfo)
{
FWorldCompositionTile* Tile = FindTileByName(InPackageName);
bool PackageDirty = false;
if (Tile)
{
PackageDirty = !(Tile->Info == InInfo);
Tile->Info = InInfo;
}
else
{
PackageDirty = true;
UWorld* OwningWorld = GetWorld();
FWorldCompositionTile NewTile;
NewTile.PackageName = InPackageName;
NewTile.Info = InInfo;
Tiles.Add(NewTile);
TilesStreaming.Add(CreateStreamingLevel(NewTile));
Tile = &Tiles.Last();
}
// Assign info to level package in case package is loaded
UPackage* LevelPackage = Cast<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), NULL, Tile->PackageName));
if (LevelPackage)
{
if (LevelPackage->WorldTileInfo == NULL)
{
LevelPackage->WorldTileInfo = new FWorldTileInfo(Tile->Info);
PackageDirty = true;
}
else
{
*(LevelPackage->WorldTileInfo) = Tile->Info;
}
if (PackageDirty)
{
LevelPackage->MarkPackageDirty();
}
}
}
void UCanvasRenderTarget2D::UpdateResource()
{
// Call parent implementation
Super::UpdateResource();
// Don't allocate canvas object for CRT2D CDO
if(IsTemplate())
{
return;
}
// Create or find the canvas object to use to render onto the texture. Multiple canvas render target textures can share the same canvas.
static const FName CanvasName( TEXT( "CanvasRenderTarget2DCanvas" ) );
UCanvas* Canvas = (UCanvas*)StaticFindObjectFast(UCanvas::StaticClass(), GetTransientPackage(), CanvasName );
if (Canvas == nullptr)
{
Canvas = ConstructObject<UCanvas>(UCanvas::StaticClass(), GetTransientPackage(), CanvasName );
Canvas->AddToRoot();
}
Canvas->Init(GetSurfaceWidth(), GetSurfaceHeight(), nullptr);
Canvas->Update();
// Update the resource immediately to remove it from the deferred resource update list. This prevents the texture
// from being cleared each frame.
UpdateResourceImmediate();
// Enqueue the rendering command to set up the rendering canvas.
ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER
(
CanvasRenderTargetMakeCurrentCommand,
FTextureRenderTarget2DResource*,
TextureRenderTarget,
(FTextureRenderTarget2DResource*)GameThread_GetRenderTargetResource(),
{
SetRenderTarget(RHICmdList, TextureRenderTarget->GetRenderTargetTexture(), FTexture2DRHIRef());
RHICmdList.SetViewport(0, 0, 0.0f, TextureRenderTarget->GetSizeXY().X, TextureRenderTarget->GetSizeXY().Y, 1.0f);
}
void UWorldComposition::RestoreDirtyTilesInfo(const FTilesList& TilesPrevState)
{
if (!TilesPrevState.Num())
{
return;
}
for (FWorldCompositionTile& Tile : Tiles)
{
UPackage* LevelPackage = Cast<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), NULL, Tile.PackageName));
if (LevelPackage && LevelPackage->IsDirty())
{
auto* FoundTile = TilesPrevState.FindByPredicate([=](const FWorldCompositionTile& TilePrev)
{
return TilePrev.PackageName == Tile.PackageName;
});
if (FoundTile)
{
Tile.Info = FoundTile->Info;
}
}
}
}
/** This will set the StreamingLevels TMap with the current Streaming Level Status and also set which level the player is in **/
void GetLevelStreamingStatus( UWorld* World, TMap<FName,int32>& StreamingLevels, FString& LevelPlayerIsInName )
{
FWorldContext &Context = GEngine->WorldContextFromWorld(World);
// Iterate over the world info's level streaming objects to find and see whether levels are loaded, visible or neither.
for( int32 LevelIndex=0; LevelIndex<World->StreamingLevels.Num(); LevelIndex++ )
{
ULevelStreaming* LevelStreaming = World->StreamingLevels[LevelIndex];
if( LevelStreaming
&& LevelStreaming->PackageName != NAME_None
&& LevelStreaming->PackageName != World->GetOutermost()->GetFName() )
{
ULevel* Level = LevelStreaming->GetLoadedLevel();
if( Level != NULL )
{
if( World->ContainsLevel( Level ) == true )
{
if( World->CurrentLevelPendingVisibility == Level )
{
StreamingLevels.Add( LevelStreaming->PackageName, LEVEL_MakingVisible );
}
else
{
StreamingLevels.Add( LevelStreaming->PackageName, LEVEL_Visible );
}
}
else
{
StreamingLevels.Add( LevelStreaming->PackageName, LEVEL_Loaded );
}
}
else
{
// See whether the level's world object is still around.
UPackage* LevelPackage = Cast<UPackage>(StaticFindObjectFast( UPackage::StaticClass(), NULL, LevelStreaming->PackageName ));
UWorld* LevelWorld = NULL;
if( LevelPackage )
{
LevelWorld = UWorld::FindWorldInPackage(LevelPackage);
}
if( LevelWorld )
{
StreamingLevels.Add( LevelStreaming->PackageName, LEVEL_UnloadedButStillAround );
}
else if( GetAsyncLoadPercentage( *LevelStreaming->PackageName.ToString() ) >= 0 )
{
StreamingLevels.Add( LevelStreaming->PackageName, LEVEL_Loading );
}
else
{
StreamingLevels.Add( LevelStreaming->PackageName, LEVEL_Unloaded );
}
}
}
}
// toss in the levels being loaded by PrepareMapChange
for( int32 LevelIndex=0; LevelIndex < Context.LevelsToLoadForPendingMapChange.Num(); LevelIndex++ )
{
const FName LevelName = Context.LevelsToLoadForPendingMapChange[LevelIndex];
StreamingLevels.Add(LevelName, LEVEL_Preloading);
}
ULevel* LevelPlayerIsIn = NULL;
for( FConstPlayerControllerIterator Iterator = World->GetPlayerControllerIterator(); Iterator; ++Iterator )
{
APlayerController* PlayerController = *Iterator;
if( PlayerController->GetPawn() != NULL )
{
// need to do a trace down here
//TraceActor = Trace( out_HitLocation, out_HitNormal, TraceDest, TraceStart, false, TraceExtent, HitInfo, true );
FHitResult Hit(1.f);
// this will not work for flying around :-(
static FName NAME_FindLevel = FName(TEXT("FindLevel"), true);
PlayerController->GetWorld()->LineTraceSingle(Hit,PlayerController->GetPawn()->GetActorLocation(), (PlayerController->GetPawn()->GetActorLocation()-FVector(0.f, 0.f, 256.f)), FCollisionQueryParams(NAME_FindLevel, true, PlayerController->GetPawn()), FCollisionObjectQueryParams(ECC_WorldStatic));
/** @todo UE4 FIXME
if( Hit.Level != NULL )
{
LevelPlayerIsIn = Hit.Level;
}
else
*/
if( Hit.GetActor() != NULL )
{
LevelPlayerIsIn = Hit.GetActor()->GetLevel();
}
else if( Hit.Component != NULL && Hit.Component->GetOwner() != NULL )
{
AActor* Owner = Hit.Component->GetOwner();
if (Owner)
{
LevelPlayerIsIn = Owner->GetLevel();
}
else
{
// This happens for BSP where the ModelComponent's outer is the level
LevelPlayerIsIn = Hit.Component->GetTypedOuter<ULevel>();
}
}
}
}
// this no longer seems to be getting the correct level name :-(
LevelPlayerIsInName = LevelPlayerIsIn != NULL ? LevelPlayerIsIn->GetOutermost()->GetName() : TEXT("None");
}
/**
* Parse and import text as property values for the object specified. This function should never be called directly - use ImportObjectProperties instead.
*
* @param ObjectStruct the struct for the data we're importing
* @param DestData the location to import the property values to
* @param SourceText pointer to a buffer containing the values that should be parsed and imported
* @param SubobjectRoot when dealing with nested subobjects, corresponds to the top-most outer that
* is not a subobject/template
* @param SubobjectOuter the outer to use for creating subobjects/components. NULL when importing structdefaultproperties
* @param Warn output device to use for log messages
* @param Depth current nesting level
* @param InstanceGraph contains the mappings of instanced objects and components to their templates
*
* @return NULL if the default values couldn't be imported
*/
static const TCHAR* ImportProperties(
uint8* DestData,
const TCHAR* SourceText,
UStruct* ObjectStruct,
UObject* SubobjectRoot,
UObject* SubobjectOuter,
FFeedbackContext* Warn,
int32 Depth,
FObjectInstancingGraph& InstanceGraph,
const TMap<FName, AActor*>* ActorRemapper
)
{
check(!GIsUCCMakeStandaloneHeaderGenerator);
check(ObjectStruct!=NULL);
check(DestData!=NULL);
if ( SourceText == NULL )
return NULL;
// Cannot create subobjects when importing struct defaults, or if SubobjectOuter (used as the Outer for any subobject declarations encountered) is NULL
bool bSubObjectsAllowed = !ObjectStruct->IsA(UScriptStruct::StaticClass()) && SubobjectOuter != NULL;
// true when DestData corresponds to a subobject in a class default object
bool bSubObject = false;
UClass* ComponentOwnerClass = NULL;
if ( bSubObjectsAllowed )
{
bSubObject = SubobjectRoot != NULL && SubobjectRoot->HasAnyFlags(RF_ClassDefaultObject);
if ( SubobjectRoot == NULL )
{
SubobjectRoot = SubobjectOuter;
}
ComponentOwnerClass = SubobjectOuter != NULL
? SubobjectOuter->IsA(UClass::StaticClass())
? CastChecked<UClass>(SubobjectOuter)
: SubobjectOuter->GetClass()
: NULL;
}
// The PortFlags to use for all ImportText calls
uint32 PortFlags = PPF_Delimited | PPF_CheckReferences;
if (GIsImportingT3D)
{
PortFlags |= PPF_AttemptNonQualifiedSearch;
}
FString StrLine;
TArray<FDefinedProperty> DefinedProperties;
// Parse all objects stored in the actor.
// Build list of all text properties.
bool ImportedBrush = 0;
int32 LinesConsumed = 0;
while (FParse::LineExtended(&SourceText, StrLine, LinesConsumed, true))
{
// remove extra whitespace and optional semicolon from the end of the line
{
int32 Length = StrLine.Len();
while ( Length > 0 &&
(StrLine[Length - 1] == TCHAR(';') || StrLine[Length - 1] == TCHAR(' ') || StrLine[Length - 1] == 9) )
{
Length--;
}
if (Length != StrLine.Len())
{
StrLine = StrLine.Left(Length);
}
}
if ( ContextSupplier != NULL )
{
ContextSupplier->CurrentLine += LinesConsumed;
}
if (StrLine.Len() == 0)
{
continue;
}
const TCHAR* Str = *StrLine;
int32 NewLineNumber;
if( FParse::Value( Str, TEXT("linenumber="), NewLineNumber ) )
{
if ( ContextSupplier != NULL )
{
ContextSupplier->CurrentLine = NewLineNumber;
}
}
else if( GetBEGIN(&Str,TEXT("Brush")) && ObjectStruct->IsChildOf(ABrush::StaticClass()) )
{
// If SubobjectOuter is NULL, we are importing defaults for a UScriptStruct's defaultproperties block
if ( !bSubObjectsAllowed )
{
Warn->Logf(ELogVerbosity::Error, TEXT("BEGIN BRUSH: Subobjects are not allowed in this context"));
return NULL;
}
// Parse brush on this line.
TCHAR BrushName[NAME_SIZE];
if( FParse::Value( Str, TEXT("Name="), BrushName, NAME_SIZE ) )
{
// If an initialized brush with this name already exists in the level, rename the existing one.
// It is deemed to be initialized if it has a non-zero poly count.
// If it is uninitialized, the existing object will have been created by a forward reference in the import text,
// and it will now be redefined. This relies on the behavior that NewObject<> will return an existing pointer
// if an object with the same name and outer is passed.
UModel* ExistingBrush = FindObject<UModel>( SubobjectRoot, BrushName );
if (ExistingBrush && ExistingBrush->Polys && ExistingBrush->Polys->Element.Num() > 0)
{
ExistingBrush->Rename();
}
// Create model.
UModelFactory* ModelFactory = NewObject<UModelFactory>();
ModelFactory->FactoryCreateText( UModel::StaticClass(), SubobjectRoot, FName(BrushName, FNAME_Add, true), RF_NoFlags, NULL, TEXT("t3d"), SourceText, SourceText+FCString::Strlen(SourceText), Warn );
ImportedBrush = 1;
}
}
else if (GetBEGIN(&Str, TEXT("Foliage")))
{
UFoliageType* SourceFoliageType;
FName ComponentName;
if (SubobjectRoot &&
ParseObject<UFoliageType>(Str, TEXT("FoliageType="), SourceFoliageType, ANY_PACKAGE) &&
FParse::Value(Str, TEXT("Component="), ComponentName) )
{
UPrimitiveComponent* ActorComponent = FindObjectFast<UPrimitiveComponent>(SubobjectRoot, ComponentName);
if (ActorComponent && ActorComponent->GetComponentLevel())
{
AInstancedFoliageActor* IFA = AInstancedFoliageActor::GetInstancedFoliageActorForLevel(ActorComponent->GetComponentLevel(), true);
FFoliageMeshInfo* MeshInfo = nullptr;
UFoliageType* FoliageType = IFA->AddFoliageType(SourceFoliageType, &MeshInfo);
const TCHAR* StrPtr;
FString TextLine;
while (MeshInfo && FParse::Line(&SourceText, TextLine))
{
StrPtr = *TextLine;
if (GetEND(&StrPtr, TEXT("Foliage")))
{
break;
}
// Parse the instance properties
FFoliageInstance Instance;
FString Temp;
if (FParse::Value(StrPtr, TEXT("Location="), Temp, false))
{
GetFVECTOR(*Temp, Instance.Location);
}
if (FParse::Value(StrPtr, TEXT("Rotation="), Temp, false))
{
GetFROTATOR(*Temp, Instance.Rotation, 1);
}
if (FParse::Value(StrPtr, TEXT("PreAlignRotation="), Temp, false))
{
GetFROTATOR(*Temp, Instance.PreAlignRotation, 1);
}
if (FParse::Value(StrPtr, TEXT("DrawScale3D="), Temp, false))
{
GetFVECTOR(*Temp, Instance.DrawScale3D);
}
FParse::Value(StrPtr, TEXT("Flags="), Instance.Flags);
// Add the instance
MeshInfo->AddInstance(IFA, FoliageType, Instance, ActorComponent);
}
}
}
}
else if( GetBEGIN(&Str,TEXT("Object")))
{
// If SubobjectOuter is NULL, we are importing defaults for a UScriptStruct's defaultproperties block
if ( !bSubObjectsAllowed )
{
Warn->Logf(ELogVerbosity::Error, TEXT("BEGIN OBJECT: Subobjects are not allowed in this context"));
return NULL;
}
// Parse subobject default properties.
// Note: default properties subobjects have compiled class as their Outer (used for localization).
UClass* TemplateClass = NULL;
bool bInvalidClass = false;
ParseObject<UClass>(Str, TEXT("Class="), TemplateClass, ANY_PACKAGE, &bInvalidClass);
if (bInvalidClass)
{
Warn->Logf(ELogVerbosity::Error,TEXT("BEGIN OBJECT: Invalid class specified: %s"), *StrLine);
return NULL;
}
// parse the name of the template
FName TemplateName = NAME_None;
FParse::Value(Str,TEXT("Name="),TemplateName);
if(TemplateName == NAME_None)
{
Warn->Logf(ELogVerbosity::Error,TEXT("BEGIN OBJECT: Must specify valid name for subobject/component: %s"), *StrLine);
return NULL;
}
// points to the parent class's template subobject/component, if we are overriding a subobject/component declared in our parent class
UObject* BaseTemplate = NULL;
bool bRedefiningSubobject = false;
if( TemplateClass )
{
}
else
{
// next, verify that a template actually exists in the parent class
UClass* ParentClass = ComponentOwnerClass->GetSuperClass();
check(ParentClass);
UObject* ParentCDO = ParentClass->GetDefaultObject();
check(ParentCDO);
BaseTemplate = StaticFindObjectFast(UObject::StaticClass(), SubobjectOuter, TemplateName);
bRedefiningSubobject = (BaseTemplate != NULL);
if (BaseTemplate == NULL)
{
BaseTemplate = StaticFindObjectFast(UObject::StaticClass(), ParentCDO, TemplateName);
}
if ( BaseTemplate == NULL )
{
// wasn't found
Warn->Logf(ELogVerbosity::Error, TEXT("BEGIN OBJECT: No base template named %s found in parent class %s: %s"), *TemplateName.ToString(), *ParentClass->GetName(), *StrLine);
return NULL;
}
TemplateClass = BaseTemplate->GetClass();
}
// because the outer won't be a default object
checkSlow(TemplateClass != NULL);
if (bRedefiningSubobject)
{
// since we're redefining an object in the same text block, only need to import properties again
SourceText = ImportObjectProperties( (uint8*)BaseTemplate, SourceText, TemplateClass, SubobjectRoot, BaseTemplate,
Warn, Depth + 1, ContextSupplier ? ContextSupplier->CurrentLine : 0, &InstanceGraph, ActorRemapper );
}
else
{
UObject* Archetype = NULL;
UObject* ComponentTemplate = NULL;
// Since we are changing the class we can't use the Archetype,
// however that is fine since we will have been editing the CDO anyways
if (!FBlueprintEditorUtils::IsAnonymousBlueprintClass(SubobjectOuter->GetClass()))
{
// if an archetype was specified in the Begin Object block, use that as the template for the ConstructObject call.
FString ArchetypeName;
if (FParse::Value(Str, TEXT("Archetype="), ArchetypeName))
{
// if given a name, break it up along the ' so separate the class from the name
FString ObjectClass;
FString ObjectPath;
if ( FPackageName::ParseExportTextPath(ArchetypeName, &ObjectClass, &ObjectPath) )
{
// find the class
UClass* ArchetypeClass = (UClass*)StaticFindObject(UClass::StaticClass(), ANY_PACKAGE, *ObjectClass);
if (ArchetypeClass)
{
// if we had the class, find the archetype
Archetype = StaticFindObject(ArchetypeClass, ANY_PACKAGE, *ObjectPath);
}
}
}
}
if (SubobjectOuter->HasAnyFlags(RF_ClassDefaultObject))
{
if (!Archetype) // if an archetype was specified explicitly, we will stick with that
{
Archetype = ComponentOwnerClass->GetDefaultSubobjectByName(TemplateName);
if(Archetype)
{
if ( BaseTemplate == NULL )
{
// BaseTemplate should only be NULL if the Begin Object line specified a class
Warn->Logf(ELogVerbosity::Error, TEXT("BEGIN OBJECT: The component name %s is already used (if you want to override the component, don't specify a class): %s"), *TemplateName.ToString(), *StrLine);
return NULL;
}
// the component currently in the component template map and the base template should be the same
checkf(Archetype==BaseTemplate,TEXT("OverrideComponent: '%s' BaseTemplate: '%s'"), *Archetype->GetFullName(), *BaseTemplate->GetFullName());
}
}
}
else // handle the non-template case (subobjects and non-template components)
{
// don't allow Actor-derived subobjects
if ( TemplateClass->IsChildOf(AActor::StaticClass()) )
{
Warn->Logf(ELogVerbosity::Error,TEXT("Cannot create subobjects from Actor-derived classes: %s"), *StrLine);
return NULL;
}
ComponentTemplate = FindObject<UObject>(SubobjectOuter, *TemplateName.ToString());
if (ComponentTemplate != NULL)
{
// if we're overriding a subobject declared in a parent class, we should already have an object with that name that
// was instanced when ComponentOwnerClass's CDO was initialized; if so, it's archetype should be the BaseTemplate. If it
// isn't, then there are two unrelated subobject definitions using the same name.
if ( ComponentTemplate->GetArchetype() != BaseTemplate )
{
}
else if ( BaseTemplate == NULL )
{
// BaseTemplate should only be NULL if the Begin Object line specified a class
Warn->Logf(ELogVerbosity::Error, TEXT("BEGIN OBJECT: A subobject named %s is already declared in a parent class. If you intended to override that subobject, don't specify a class in the derived subobject definition: %s"), *TemplateName.ToString(), *StrLine);
return NULL;
}
}
}
// Propagate object flags to the sub object.
EObjectFlags NewFlags = SubobjectOuter->GetMaskedFlags( RF_PropagateToSubObjects );
if (!Archetype) // no override and we didn't find one from the class table, so go with the base
{
Archetype = BaseTemplate;
}
UObject* OldComponent = NULL;
if (ComponentTemplate)
{
bool bIsOkToReuse = ComponentTemplate->GetClass() == TemplateClass
&& ComponentTemplate->GetOuter() == SubobjectOuter
&& ComponentTemplate->GetFName() == TemplateName
&& (ComponentTemplate->GetArchetype() == Archetype || !Archetype);
if (!bIsOkToReuse)
{
UE_LOG(LogEditorObject, Log, TEXT("Could not reuse component instance %s, name clash?"), *ComponentTemplate->GetFullName());
ComponentTemplate->Rename(); // just abandon the existing component, we are going to create
OldComponent = ComponentTemplate;
ComponentTemplate = NULL;
}
}
if (!ComponentTemplate)
{
ComponentTemplate = NewObject<UObject>(
SubobjectOuter,
TemplateClass,
TemplateName,
NewFlags,
Archetype,
!!SubobjectOuter,
&InstanceGraph
);
}
else
{
// We do not want to set RF_Transactional for construction script created components, so we have to monkey with things here
if (NewFlags & RF_Transactional)
{
UActorComponent* Component = Cast<UActorComponent>(ComponentTemplate);
if (Component && Component->IsCreatedByConstructionScript())
{
NewFlags &= ~RF_Transactional;
}
}
// Make sure desired flags are set - existing object could be pending kill
ComponentTemplate->ClearFlags(RF_AllFlags);
ComponentTemplate->SetFlags(NewFlags);
}
// replace all properties in this subobject outer' class that point to the original subobject with the new subobject
TMap<UObject*, UObject*> ReplacementMap;
if (Archetype)
{
checkSlow(ComponentTemplate->GetArchetype() == Archetype);
ReplacementMap.Add(Archetype, ComponentTemplate);
InstanceGraph.AddNewInstance(ComponentTemplate);
}
if (OldComponent)
{
ReplacementMap.Add(OldComponent, ComponentTemplate);
}
FArchiveReplaceObjectRef<UObject> ReplaceAr(SubobjectOuter, ReplacementMap, false, false, true);
// import the properties for the subobject
SourceText = ImportObjectProperties(
(uint8*)ComponentTemplate,
SourceText,
TemplateClass,
SubobjectRoot,
ComponentTemplate,
Warn,
Depth+1,
ContextSupplier ? ContextSupplier->CurrentLine : 0,
&InstanceGraph,
ActorRemapper
);
}
}
else if( FParse::Command(&Str,TEXT("CustomProperties")))
{
check(SubobjectOuter);
SubobjectOuter->ImportCustomProperties(Str, Warn);
}
else if( GetEND(&Str,TEXT("Actor")) || GetEND(&Str,TEXT("DefaultProperties")) || GetEND(&Str,TEXT("structdefaultproperties")) || (GetEND(&Str,TEXT("Object")) && Depth) )
{
// End of properties.
break;
}
else if( GetREMOVE(&Str,TEXT("Component")) )
{
checkf(false, TEXT("Remove component is illegal in pasted text"));
}
else
{
// Property.
UProperty::ImportSingleProperty(Str, DestData, ObjectStruct, SubobjectOuter, PortFlags, Warn, DefinedProperties);
}
}
if (ActorRemapper)
{
for (const auto& DefinedProperty : DefinedProperties)
{
RemapProperty(DefinedProperty.Property, DefinedProperty.Index, *ActorRemapper, DestData);
}
}
// Prepare brush.
if( ImportedBrush && ObjectStruct->IsChildOf<ABrush>() && !ObjectStruct->IsChildOf<AVolume>() )
{
check(GIsEditor);
ABrush* Actor = (ABrush*)DestData;
check(Actor->GetBrushComponent());
if( Actor->GetBrushComponent()->Mobility == EComponentMobility::Static )
{
// Prepare static brush.
Actor->SetNotForClientOrServer();
}
else
{
// Prepare moving brush.
FBSPOps::csgPrepMovingBrush( Actor );
}
}
return SourceText;
}
void UKUISubContainerRenderCache::UpdateRenderCache( UKUIInterfaceElement* oElement )
{
if ( oElement == NULL )
{
KUIErrorUO( "Null element" );
return;
}
KUILogUO( "Updating Render Cache" );
UKUISubContainer* const ctSub = Cast<UKUISubContainer>( oElement );
const FVector2D v2ElemSize = ctSub->GetTotalSize();
if ( v2ElemSize.X < 1.f || v2ElemSize.Y < 1.f )
{
KUIErrorUO( "Element is zero size" );
return;
}
bool bRebuildTexture = false;
if ( GetTexture() == NULL )
bRebuildTexture = true;
else if ( v2ElemSize.X != GetTexture()->GetSurfaceWidth() || v2ElemSize.Y != GetTexture()->GetSurfaceHeight() )
bRebuildTexture = true;
if ( bRebuildTexture )
CreateRenderCache( v2ElemSize );
if ( GetTexture() == NULL )
{
KUIErrorUO( "Texture is null" );
return;
}
if ( !GetTexture()->IsA<UTextureRenderTarget2D>() )
{
KUIErrorUO( "Texture is not a render target" );
return;
}
UTextureRenderTarget2D* const tRenderTarget = Cast<UTextureRenderTarget2D>( GetTexture() );
tRenderTarget->UpdateResource();
tRenderTarget->UpdateResourceImmediate();
UCanvas* uoCanvas = Cast<UCanvas>( StaticFindObjectFast( UCanvas::StaticClass(), GetTransientPackage(), FName( TEXT( "Sub Container Render Cache Canvas" ) ) ) );
if ( uoCanvas == NULL )
{
uoCanvas = NewObject<UCanvas>( GetTransientPackage(), FName( TEXT( "Sub Container Render Cache Canvas" ) ) );
uoCanvas->AddToRoot();
}
uoCanvas->Init( floor( v2ElemSize.X ), floor( v2ElemSize.Y ), NULL );
uoCanvas->Update();
ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER(
CanvasRenderTargetMakeCurrentCommand,
FTextureRenderTarget2DResource*,
TextureRenderTarget,
static_cast<FTextureRenderTarget2DResource*>( tRenderTarget->GameThread_GetRenderTargetResource() ),
{
SetRenderTarget( RHICmdList, TextureRenderTarget->GetRenderTargetTexture(), FTexture2DRHIRef() );
RHICmdList.SetViewport( 0, 0, 0.0f, TextureRenderTarget->GetSizeXY().X, TextureRenderTarget->GetSizeXY().Y, 1.0f );
}
UObject* FObjectInstancingGraph::GetInstancedSubobject( UObject* SourceSubobject, UObject* CurrentValue, UObject* CurrentObject, bool bDoNotCreateNewInstance, bool bAllowSelfReference )
{
checkSlow(SourceSubobject);
UObject* InstancedSubobject = INVALID_OBJECT;
if ( SourceSubobject != NULL && CurrentValue != NULL )
{
bool bAllowedSelfReference = bAllowSelfReference && SourceSubobject == SourceRoot;
bool bShouldInstance = bAllowedSelfReference || SourceSubobject->IsIn(SourceRoot);
if ( !bShouldInstance && CurrentValue->GetOuter() == CurrentObject->GetArchetype() )
{
// this code is intended to catch cases where SourceRoot contains subobjects assigned to instanced object properties, where the subobject's class
// contains components, and the class of the subobject is outside of the inheritance hierarchy of the SourceRoot, for example, a weapon
// class which contains UIObject subobject definitions in its defaultproperties, where the property referencing the UIObjects is marked instanced.
bShouldInstance = true;
// if this case is triggered, ensure that the CurrentValue of the component property is still pointing to the template component.
check(SourceSubobject == CurrentValue);
}
if ( bShouldInstance )
{
// search for the unique component instance that corresponds to this component template
InstancedSubobject = GetDestinationObject(SourceSubobject);
if ( InstancedSubobject == NULL )
{
if (bDoNotCreateNewInstance)
{
InstancedSubobject = INVALID_OBJECT; // leave it unchanged
}
else
{
// if the Outer for the component currently assigned to this property is the same as the object that we're instancing components for,
// the component does not need to be instanced; otherwise, there are two possiblities:
// 1. CurrentValue is a template and needs to be instanced
// 2. CurrentValue is an instanced component, in which case it should already be in InstanceGraph, UNLESS the component was created
// at runtime (editinline export properties, for example). If that is the case, CurrentValue will be an instance that is not linked
// to the component template referenced by CurrentObject's archetype, and in this case, we also don't want to re-instance the component template
bool bIsRuntimeInstance = CurrentValue != SourceSubobject && CurrentValue->GetOuter() == CurrentObject;
if ( bDoNotCreateNewInstance || bIsRuntimeInstance )
{
InstancedSubobject = CurrentValue;
}
else
{
// If the component template is relevant in this context(client vs server vs editor), instance it.
const bool bShouldLoadForClient = SourceSubobject->NeedsLoadForClient();
const bool bShouldLoadForServer = SourceSubobject->NeedsLoadForServer();
const bool bShouldLoadForEditor = ( GIsEditor && ( bShouldLoadForClient || !CurrentObject->RootPackageHasAnyFlags(PKG_PlayInEditor) ) );
if ( ((GIsClient && bShouldLoadForClient) || (GIsServer && bShouldLoadForServer) || bShouldLoadForEditor) )
{
// this is the first time the instance corresponding to SourceSubobject has been requested
// get the object instance corresponding to the source component's Outer - this is the object that
// will be used as the Outer for the destination component
UObject* SubobjectOuter = GetDestinationObject(SourceSubobject->GetOuter());
checkf(SubobjectOuter, TEXT("No corresponding destination object found for '%s' while attempting to instance component '%s'"), *SourceSubobject->GetOuter()->GetFullName(), *SourceSubobject->GetFullName());
FName SubobjectName = SourceSubobject->GetFName();
// final archetype archetype will be the archetype of the template
UObject* FinalSubobjectArchetype = CurrentValue->GetArchetype();
// Don't seach for the existing subobjects on Blueprint-generated classes. What we'll find is a subobject
// created by the constructor which may not have all of its fields initialized to the correct value (which
// should be coming from a blueprint).
// NOTE: Since this function is called ONLY for Blueprint-generated classes, we may as well delete this 'if'.
if (!SubobjectOuter->GetClass()->HasAnyClassFlags(CLASS_CompiledFromBlueprint))
{
InstancedSubobject = StaticFindObjectFast(NULL, SubobjectOuter, SubobjectName);
}
if (InstancedSubobject && IsCreatingArchetype())
{
// since we are updating an archetype, this needs to reconstruct as that is the mechanism used to copy properties
// it will destroy the existing object and overwrite it
InstancedSubobject = NULL;
}
if (!InstancedSubobject)
{
// finally, create the component instance
InstancedSubobject = ConstructObject<UObject>(SourceSubobject->GetClass(), SubobjectOuter,
SubobjectName, SubobjectOuter->GetMaskedFlags(RF_PropagateToSubObjects), SourceSubobject,
true, this);
}
}
}
}
}
else if ( IsLoadingObject() && InstancedSubobject->GetClass()->HasAnyClassFlags(CLASS_HasInstancedReference) )
{
/* When loading an object from disk, in some cases we have a component which has a reference to another component in DestinationObject which
wasn't serialized and hasn't yet been instanced. For example, the PointLight class declared two component templates:
Begin DrawLightRadiusComponent0
End
Components.Add(DrawLightRadiusComponent0)
Begin MyPointLightComponent
SomeProperty=DrawLightRadiusComponent
End
LightComponent=MyPointLightComponent
The components array will be processed by UClass::InstanceSubobjectTemplates after the LightComponent property is processed. If the instance
of DrawLightRadiusComponent0 that was created during the last session (i.e. when this object was saved) was identical to the component template
from the PointLight class's defaultproperties, and the instance of MyPointLightComponent was serialized, then the MyPointLightComponent instance will
exist in the InstanceGraph, but the instance of DrawLightRadiusComponent0 will not. To handle this case and make sure that the SomeProperty variable of
the MyPointLightComponent instance is correctly set to the value of the DrawLightRadiusComponent0 instance that will be created as a result of calling
InstanceSubobjectTemplates on the PointLight actor from ConditionalPostLoad, we must call ConditionalPostLoad on each existing component instance that we
encounter, while we still have access to all of the component instances owned by the PointLight.
*/
InstancedSubobject->ConditionalPostLoadSubobjects(this);
}
}
}
return InstancedSubobject;
}
bool ULevelStreaming::RequestLevel(UWorld* PersistentWorld, bool bAllowLevelLoadRequests, bool bBlockOnLoad)
{
// Quit early in case load request already issued
if (bHasLoadRequestPending)
{
return true;
}
// Previous attempts have failed, no reason to try again
if (bFailedToLoad)
{
return false;
}
QUICK_SCOPE_CYCLE_COUNTER(STAT_ULevelStreaming_RequestLevel);
FScopeCycleCounterUObject Context(PersistentWorld);
// Package name we want to load
FName DesiredPackageName = PersistentWorld->IsGameWorld() ? GetLODPackageName() : GetWorldAssetPackageFName();
FName DesiredPackageNameToLoad = PersistentWorld->IsGameWorld() ? GetLODPackageNameToLoad() : PackageNameToLoad;
// Check if currently loaded level is what we want right now
if (LoadedLevel != NULL &&
LoadedLevel->GetOutermost()->GetFName() == DesiredPackageName)
{
return true;
}
// Can not load new level now, there is still level pending unload
if (PendingUnloadLevel != NULL)
{
return false;
}
// Try to find the [to be] loaded package.
UPackage* LevelPackage = (UPackage*) StaticFindObjectFast(UPackage::StaticClass(), NULL, DesiredPackageName, 0, 0, RF_PendingKill);
// Package is already or still loaded.
if (LevelPackage)
{
// Find world object and use its PersistentLevel pointer.
UWorld* World = UWorld::FindWorldInPackage(LevelPackage);
// Check for a redirector. Follow it, if found.
if ( !World )
{
World = UWorld::FollowWorldRedirectorInPackage(LevelPackage);
if ( World )
{
LevelPackage = World->GetOutermost();
}
}
if (World != NULL)
{
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
if (World->PersistentLevel == NULL)
{
UE_LOG(LogLevelStreaming, Log, TEXT("World exists but PersistentLevel doesn't for %s, most likely caused by reference to world of unloaded level and GC setting reference to NULL while keeping world object"), *World->GetOutermost()->GetName());
// print out some debug information...
StaticExec(World, *FString::Printf(TEXT("OBJ REFS CLASS=WORLD NAME=%s shortest"), *World->GetPathName()));
TMap<UObject*,UProperty*> Route = FArchiveTraceRoute::FindShortestRootPath( World, true, GARBAGE_COLLECTION_KEEPFLAGS );
FString ErrorString = FArchiveTraceRoute::PrintRootPath( Route, World );
UE_LOG(LogLevelStreaming, Log, TEXT("%s"), *ErrorString);
// before asserting
checkf(World->PersistentLevel,TEXT("Most likely caused by reference to world of unloaded level and GC setting reference to NULL while keeping world object"));
return false;
}
#endif
if (World->PersistentLevel != LoadedLevel)
{
SetLoadedLevel(World->PersistentLevel);
// Broadcast level loaded event to blueprints
OnLevelLoaded.Broadcast(this);
}
return true;
}
}
EPackageFlags PackageFlags = PKG_None;
int32 PIEInstanceID = INDEX_NONE;
// copy streaming level on demand if we are in PIE
// (the world is already loaded for the editor, just find it and copy it)
if ( PersistentWorld->IsPlayInEditor() )
{
#if WITH_EDITOR
if (PersistentWorld->GetOutermost()->HasAnyPackageFlags(PKG_PlayInEditor))
{
PackageFlags |= PKG_PlayInEditor;
}
PIEInstanceID = PersistentWorld->GetOutermost()->PIEInstanceID;
#endif
const FString NonPrefixedLevelName = UWorld::StripPIEPrefixFromPackageName(DesiredPackageName.ToString(), PersistentWorld->StreamingLevelsPrefix);
UPackage* EditorLevelPackage = FindObjectFast<UPackage>(nullptr, FName(*NonPrefixedLevelName));
bool bShouldDuplicate = EditorLevelPackage && (bBlockOnLoad || EditorLevelPackage->IsDirty() || !GEngine->PreferToStreamLevelsInPIE());
if (bShouldDuplicate)
{
// Do the duplication
UWorld* PIELevelWorld = UWorld::DuplicateWorldForPIE(NonPrefixedLevelName, PersistentWorld);
if (PIELevelWorld)
{
PIELevelWorld->PersistentLevel->bAlreadyMovedActors = true; // As we have duplicated the world, the actors will already have been transformed
check(PendingUnloadLevel == NULL);
SetLoadedLevel(PIELevelWorld->PersistentLevel);
// Broadcast level loaded event to blueprints
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_OnLevelLoaded_Broadcast);
OnLevelLoaded.Broadcast(this);
}
return true;
}
else if (PersistentWorld->WorldComposition == NULL) // In world composition streaming levels are not loaded by default
{
if ( bAllowLevelLoadRequests )
{
UE_LOG(LogLevelStreaming, Log, TEXT("World to duplicate for PIE '%s' not found. Attempting load."), *NonPrefixedLevelName);
}
else
{
UE_LOG(LogLevelStreaming, Warning, TEXT("Unable to duplicate PIE World: '%s'"), *NonPrefixedLevelName);
}
}
}
}
// Async load package if world object couldn't be found and we are allowed to request a load.
if (bAllowLevelLoadRequests)
{
FString PackageNameToLoadFrom = DesiredPackageName.ToString();
if (DesiredPackageNameToLoad != NAME_None)
{
PackageNameToLoadFrom = DesiredPackageNameToLoad.ToString();
}
if (GUseSeekFreeLoading)
{
// Only load localized package if it exists as async package loading doesn't handle errors gracefully.
FString LocalizedPackageName = PackageNameToLoadFrom + LOCALIZED_SEEKFREE_SUFFIX;
FString LocalizedFileName;
if (FPackageName::DoesPackageExist(LocalizedPackageName, NULL, &LocalizedFileName))
{
// Load localized part of level first in case it exists. We don't need to worry about GC or completion
// callback as we always kick off another async IO for the level below.
LoadPackageAsync(*(GetWorldAssetPackageName() + LOCALIZED_SEEKFREE_SUFFIX), nullptr, *LocalizedPackageName, FLoadPackageAsyncDelegate(), PackageFlags, PIEInstanceID);
}
}
if (FPackageName::DoesPackageExist(PackageNameToLoadFrom, NULL, NULL))
{
bHasLoadRequestPending = true;
ULevel::StreamedLevelsOwningWorld.Add(DesiredPackageName, PersistentWorld);
UWorld::WorldTypePreLoadMap.FindOrAdd(DesiredPackageName) = PersistentWorld->WorldType;
// Kick off async load request.
STAT_ADD_CUSTOMMESSAGE_NAME( STAT_NamedMarker, *(FString( TEXT( "RequestLevel - " ) + DesiredPackageName.ToString() )) );
LoadPackageAsync(DesiredPackageName.ToString(), nullptr, *PackageNameToLoadFrom, FLoadPackageAsyncDelegate::CreateUObject(this, &ULevelStreaming::AsyncLevelLoadComplete), PackageFlags, PIEInstanceID);
// streamingServer: server loads everything?
// Editor immediately blocks on load and we also block if background level streaming is disabled.
if (bBlockOnLoad || ShouldBeAlwaysLoaded())
{
// Finish all async loading.
FlushAsyncLoading();
}
}
else
{
UE_LOG(LogStreaming, Error,TEXT("Couldn't find file for package %s."), *PackageNameToLoadFrom);
bFailedToLoad = true;
return false;
}
}
return true;
}
FWorldTileModel::FWorldTileModel(const TWeakObjectPtr<UEditorEngine>& InEditor,
FWorldTileCollectionModel& InWorldModel,
int32 InTileIdx)
: FLevelModel(InWorldModel, InEditor)
, TileIdx(InTileIdx)
, TileDetails(NULL)
, bWasShelved(false)
{
UWorldComposition* WorldComposition = LevelCollectionModel.GetWorld()->WorldComposition;
// Tile display details object
TileDetails = Cast<UWorldTileDetails>(
StaticConstructObject(UWorldTileDetails::StaticClass(),
GetTransientPackage(), NAME_None, RF_RootSet|RF_Transient, NULL
)
);
// Subscribe to tile properties changes
TileDetails->PositionChangedEvent.AddRaw(this, &FWorldTileModel::OnPositionPropertyChanged);
TileDetails->ParentPackageNameChangedEvent.AddRaw(this, &FWorldTileModel::OnParentPackageNamePropertyChanged);
TileDetails->AlwaysLoadedChangedEvent.AddRaw(this, &FWorldTileModel::OnAlwaysLoadedPropertyChanged);
TileDetails->StreamingLevelsChangedEvent.AddRaw(this, &FWorldTileModel::OnStreamingLevelsPropertyChanged);
TileDetails->LODSettingsChangedEvent.AddRaw(this, &FWorldTileModel::OnLODSettingsPropertyChanged);
TileDetails->ZOrderChangedEvent.AddRaw(this, &FWorldTileModel::OnZOrderPropertyChanged);
// Initialize tile details
if (WorldComposition->GetTilesList().IsValidIndex(TileIdx))
{
FWorldCompositionTile& Tile = WorldComposition->GetTilesList()[TileIdx];
TileDetails->SetInfo(Tile.Info);
TileDetails->SyncStreamingLevels(*this);
TileDetails->PackageName = Tile.PackageName;
TileDetails->bPersistentLevel = false;
// Asset name for storing tile thumbnail inside package
//FString AssetNameString = FString::Printf(TEXT("%s %s.TheWorld:PersistentLevel"), *ULevel::StaticClass()->GetName(), *Tile.PackageName.ToString());
FString AssetNameString = FString::Printf(TEXT("%s %s"), *UPackage::StaticClass()->GetName(), *Tile.PackageName.ToString());
AssetName = FName(*AssetNameString);
// Assign level object in case this level already loaded
UPackage* LevelPackage = Cast<UPackage>(StaticFindObjectFast( UPackage::StaticClass(), NULL, Tile.PackageName) );
if (LevelPackage)
{
// Find the world object
UWorld* World = UWorld::FindWorldInPackage(LevelPackage);
if (World)
{
LoadedLevel = World->PersistentLevel;
// Enable tile properties
TileDetails->bTileEditable = true;
}
}
}
else
{
TileDetails->PackageName = LevelCollectionModel.GetWorld()->GetOutermost()->GetFName();
TileDetails->bPersistentLevel = true;
LoadedLevel = LevelCollectionModel.GetWorld()->PersistentLevel;
}
}
