bool VerifyServiceTask::checkFiles()
{
if (HasAnyFlags(m_uiOldStatus, UserCore::Item::ItemInfoI::STATUS_DOWNLOADING))
{
gcString path;
if (checkMcfDownload(path))
finishVerify(UserCore::Misc::VerifyComplete::V_DOWNLOAD, path.c_str());
else
finishVerify(UserCore::Misc::VerifyComplete::V_DOWNLOAD);
return false;
}
else if (HasAnyFlags(m_uiOldStatus, (UserCore::Item::ItemInfoI::STATUS_INSTALLED|UserCore::Item::ItemInfoI::STATUS_INSTALLING)))
{
m_hMcf->getProgEvent() += delegate(this, &VerifyServiceTask::onProgress);
m_hMcf->getErrorEvent() += delegate(this, &VerifyServiceTask::onError);
bool completeMcf = false;
if (m_McfBuild == 0)
m_McfBuild = getItemInfo()->getInstalledBuild();
setTier(VERIFYMCF);
if (!checkMcf(completeMcf))
return false;
setTier(VERIFYINSTALL);
if (!checkInstall(completeMcf))
return false;
setTier(DOWNLOADMISSINGFILES);
if (completeMcf == false && !downloadMissingFiles())
return false;
setTier(INSTALLMISSINGFILES);
if (!installMissingFiles())
return false;
}
else
{
getItemInfo()->delSFlag(UserCore::Item::ItemInfoI::STATUS_READY);
finishVerify(UserCore::Misc::VerifyComplete::V_RESET);
return false;
}
return true;
}
void UParticleModuleParameterDynamic::PostInitProperties()
{
Super::PostInitProperties();
if (!HasAnyFlags(RF_ClassDefaultObject | RF_NeedLoad))
{
// Structure to hold one-time initialization
struct FConstructorStatics
{
FName NAME_None;
FConstructorStatics()
: NAME_None(TEXT("None"))
{
}
};
static FConstructorStatics ConstructorStatics;
UDistributionFloatConstant* NewParam1 = NewObject<UDistributionFloatConstant>(this, TEXT("DistributionParam1")); NewParam1->Constant = 1.0f;
UDistributionFloatConstant* NewParam2 = NewObject<UDistributionFloatConstant>(this, TEXT("DistributionParam2")); NewParam2->Constant = 1.0f;
UDistributionFloatConstant* NewParam3 = NewObject<UDistributionFloatConstant>(this, TEXT("DistributionParam3")); NewParam3->Constant = 1.0f;
UDistributionFloatConstant* NewParam4 = NewObject<UDistributionFloatConstant>(this, TEXT("DistributionParam4")); NewParam4->Constant = 1.0f;
DynamicParams.Add(FEmitterDynamicParameter(ConstructorStatics.NAME_None, false, EDPV_UserSet, NewParam1));
DynamicParams.Add(FEmitterDynamicParameter(ConstructorStatics.NAME_None, false, EDPV_UserSet, NewParam2));
DynamicParams.Add(FEmitterDynamicParameter(ConstructorStatics.NAME_None, false, EDPV_UserSet, NewParam3));
DynamicParams.Add(FEmitterDynamicParameter(ConstructorStatics.NAME_None, false, EDPV_UserSet, NewParam4));
}
}
void UClassProperty::Serialize( FArchive& Ar )
{
Super::Serialize( Ar );
Ar << MetaClass;
#if USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
if (Ar.IsLoading() || Ar.IsObjectReferenceCollector())
{
if (ULinkerPlaceholderClass* PlaceholderClass = Cast<ULinkerPlaceholderClass>(MetaClass))
{
PlaceholderClass->AddReferencingProperty(this);
}
}
#endif // USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
if( !(MetaClass||HasAnyFlags(RF_ClassDefaultObject)) )
{
// If we failed to load the MetaClass and we're not a CDO, that means we relied on a class that has been removed or doesn't exist.
// The most likely cause for this is either an incomplete recompile, or if content was migrated between games that had native class dependencies
// that do not exist in this game. We allow blueprint classes to continue, because compile on load will error out, and stub the class that was using it
UClass* TestClass = dynamic_cast<UClass*>(GetOwnerStruct());
if( TestClass && TestClass->HasAllClassFlags(CLASS_Native) && !TestClass->HasAllClassFlags(CLASS_NewerVersionExists) && (TestClass->GetOutermost() != GetTransientPackage()) )
{
checkf(false, TEXT("Class property tried to serialize a missing class. Did you remove a native class and not fully recompile?"));
}
}
}
APawn::APawn(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
PrimaryActorTick.bCanEverTick = true;
PrimaryActorTick.TickGroup = TG_PrePhysics;
AutoPossessAI = EAutoPossessAI::PlacedInWorld;
if (HasAnyFlags(RF_ClassDefaultObject) && GetClass() == APawn::StaticClass())
{
AIControllerClass = LoadClass<AController>(NULL, *((UEngine*)(UEngine::StaticClass()->GetDefaultObject()))->AIControllerClassName.ToString(), NULL, LOAD_None, NULL);
}
else
{
AIControllerClass = ((APawn*)APawn::StaticClass()->GetDefaultObject())->AIControllerClass;
}
bCanBeDamaged = true;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
NetPriority = 3.0f;
NetUpdateFrequency = 100.f;
bReplicateMovement = true;
BaseEyeHeight = 64.0f;
AllowedYawError = 10.99f;
bCollideWhenPlacing = true;
SpawnCollisionHandlingMethod = ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButDontSpawnIfColliding;
bProcessingOutsideWorldBounds = false;
bUseControllerRotationPitch = false;
bUseControllerRotationYaw = false;
bUseControllerRotationRoll = false;
bInputEnabled = true;
}
UGUIWidget::UGUIWidget(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
OpenCloseTween = ObjectInitializer.CreateDefaultSubobject<UTweeningBoolean>(this, "OpenCloseTweenDefault");
if ( OpenCloseTween )
{
if ( HasAnyFlags(RF_ClassDefaultObject | RF_ArchetypeObject) )
{
FTweeningBooleanParameters Params;
Params.TweenParamsIn = FTweenParameters(EEaseType::Linear, 0.f);
Params.TweenParamsOut = FTweenParameters(EEaseType::Linear, 0.f);
Params.bInitialValue = true;
OpenCloseTween->SetParams( Params );
}
else
{
//OpenCloseTween->OnValueChanged.AddUObject( this, &UGUIWidget::OnOpenClose );
OpenCloseTween->OnTweening.AddUObject( this, &UGUIWidget::OnOpenCloseTweening );
OpenCloseTween->OnFinished.AddUObject( this, &UGUIWidget::OnOpenCloseFinished );
}
}
Tweener = ObjectInitializer.CreateDefaultSubobject<UTweener>(this, "TweenerDefault");
BooleanTweener = ObjectInitializer.CreateDefaultSubobject<UBooleanTweener>(this, "BooleanTweenerDefault");
StateMachine = ObjectInitializer.CreateDefaultSubobject<UTweeningStateMachine>(this, "StateMachineDefault");
}
void UActorComponent::DoDeferredRenderUpdates_Concurrent()
{
checkf(!HasAnyFlags(RF_Unreachable), TEXT("%s"), *GetFullName());
checkf(!IsTemplate(), TEXT("%s"), *GetFullName());
checkf(!IsPendingKill(), TEXT("%s"), *GetFullName());
if(!IsRegistered())
{
UE_LOG(LogActorComponent, Log, TEXT("UpdateComponent: (%s) Not registered, Aborting."), *GetPathName());
return;
}
if(bRenderStateDirty)
{
SCOPE_CYCLE_COUNTER(STAT_PostTickComponentRecreate);
RecreateRenderState_Concurrent();
checkf(!bRenderStateDirty, TEXT("Failed to route CreateRenderState_Concurrent (%s)"), *GetFullName());
}
else
{
SCOPE_CYCLE_COUNTER(STAT_PostTickComponentLW);
if(bRenderTransformDirty)
{
// Update the component's transform if the actor has been moved since it was last updated.
SendRenderTransform_Concurrent();
}
if(bRenderDynamicDataDirty)
{
SendRenderDynamicData_Concurrent();
}
}
}
UGameplayAbility::UGameplayAbility(const class FPostConstructInitializeProperties& PCIP)
: Super(PCIP)
{
CostGameplayEffect = NULL;
CooldownGameplayEffect = NULL;
{
static FName FuncName = FName(TEXT("K2_ShouldAbilityRespondToEvent"));
UFunction* ShouldRespondFunction = GetClass()->FindFunctionByName(FuncName);
HasBlueprintShouldAbilityRespondToEvent = ShouldRespondFunction && ShouldRespondFunction->GetOuter()->IsA(UBlueprintGeneratedClass::StaticClass());
}
{
static FName FuncName = FName(TEXT("K2_CanActivateAbility"));
UFunction* CanActivateFunction = GetClass()->FindFunctionByName(FuncName);
HasBlueprintCanUse = CanActivateFunction && CanActivateFunction->GetOuter()->IsA(UBlueprintGeneratedClass::StaticClass());
}
{
static FName FuncName = FName(TEXT("K2_ActivateAbility"));
UFunction* ActivateFunction = GetClass()->FindFunctionByName(FuncName);
HasBlueprintActivate = ActivateFunction && ActivateFunction->GetOuter()->IsA(UBlueprintGeneratedClass::StaticClass());
}
#if WITH_EDITOR
/** Autoregister abilities with the blueprint debugger in the editor.*/
if (!HasAnyFlags(RF_ClassDefaultObject))
{
UBlueprint* BP = Cast<UBlueprint>(GetClass()->ClassGeneratedBy);
if (BP && (BP->GetWorldBeingDebugged() == nullptr || BP->GetWorldBeingDebugged() == GetWorld()))
{
BP->SetObjectBeingDebugged(this);
}
}
#endif
}
void ANavigationData::PostInitProperties()
{
Super::PostInitProperties();
if (IsPendingKill() == true)
{
return;
}
if (HasAnyFlags(RF_ClassDefaultObject))
{
if (RuntimeGeneration == ERuntimeGenerationType::LegacyGeneration)
{
RuntimeGeneration = bRebuildAtRuntime_DEPRECATED ? ERuntimeGenerationType::Dynamic : ERuntimeGenerationType::Static;
}
}
else
{
bNetLoadOnClient = (*GEngine->NavigationSystemClass != nullptr) && (GEngine->NavigationSystemClass->GetDefaultObject<UNavigationSystem>()->ShouldLoadNavigationOnClient(this));
UWorld* WorldOuter = GetWorld();
if (WorldOuter != NULL && WorldOuter->GetNavigationSystem() != NULL)
{
WorldOuter->GetNavigationSystem()->RequestRegistration(this);
}
RenderingComp = ConstructRenderingComponent();
}
}
void UObject::SetLinker( FLinkerLoad* LinkerLoad, int32 LinkerIndex, bool bShouldDetachExisting )
{
FLinkerIndexPair Existing = LinkerAnnotation.GetAnnotation(this);
Existing.CheckInvariants();
// Detach from existing linker.
if( Existing.Linker && bShouldDetachExisting )
{
checkf(!HasAnyFlags(RF_NeedLoad|RF_NeedPostLoad), TEXT("Detaching from existing linker for %s while object %s needs loaded"), *Existing.Linker->GetArchiveName(), *GetFullName());
check(Existing.Linker->ExportMap[Existing.LinkerIndex].Object!=NULL);
check(Existing.Linker->ExportMap[Existing.LinkerIndex].Object==this);
Existing.Linker->ExportMap[Existing.LinkerIndex].Object = NULL;
}
if (Existing.Linker == LinkerLoad)
{
bShouldDetachExisting = false; // no change so don't call notify
}
LinkerAnnotation.AddAnnotation(this,FLinkerIndexPair(LinkerLoad,LinkerIndex));
if (bShouldDetachExisting)
{
#if WITH_EDITOR
PostLinkerChange();
#else
UE_CLOG(Existing.Linker && LinkerLoad, LogUObjectLinker, Fatal,
TEXT("It is only legal to change linkers in the editor. Trying to change linker on %s from %s (Existing->LinkerRoot=%s) to %s (LinkerLoad->LinkerRoot=%s)"),
*GetFullName(),
*Existing.Linker->Filename,
*GetNameSafe(Existing.Linker->LinkerRoot),
*LinkerLoad->Filename,
*GetNameSafe(LinkerLoad->LinkerRoot));
#endif
}
}
void UUserWidget::Initialize()
{
// If it's not initialized initialize it, as long as it's not the CDO, we never initialize the CDO.
if ( !bInitialized && !HasAnyFlags(RF_ClassDefaultObject) )
{
bInitialized = true;
// Only do this if this widget is of a blueprint class
UWidgetBlueprintGeneratedClass* BGClass = Cast<UWidgetBlueprintGeneratedClass>(GetClass());
if ( BGClass != nullptr )
{
BGClass->InitializeWidget(this);
}
// Map the named slot bindings to the available slots.
WidgetTree->ForEachWidget([&] (UWidget* Widget) {
if ( UNamedSlot* NamedWidet = Cast<UNamedSlot>(Widget) )
{
for ( FNamedSlotBinding& Binding : NamedSlotBindings )
{
if ( Binding.Content && Binding.Name == NamedWidet->GetFName() )
{
NamedWidet->ClearChildren();
NamedWidet->AddChild(Binding.Content);
return;
}
}
}
});
// TODO Find a way to remove the bindings from the table. Currently they're still needed.
// Clear the named slot bindings table.
//NamedSlotBindings.Reset();
}
}
UGameplayDebuggerSettings::UGameplayDebuggerSettings(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer)
{
if (HasAnyFlags(RF_ClassDefaultObject))
{
/*read base default values from Engine config file. It can be overridden (locally) by Editor settings*/
GConfig->GetString(TEXT("GameplayDebuggerSettings"), TEXT("NameForGameView1"), CustomViewNames.GameView1, GEngineIni);
GConfig->GetString(TEXT("GameplayDebuggerSettings"), TEXT("NameForGameView2"), CustomViewNames.GameView2, GEngineIni);
GConfig->GetString(TEXT("GameplayDebuggerSettings"), TEXT("NameForGameView3"), CustomViewNames.GameView3, GEngineIni);
GConfig->GetString(TEXT("GameplayDebuggerSettings"), TEXT("NameForGameView4"), CustomViewNames.GameView4, GEngineIni);
GConfig->GetString(TEXT("GameplayDebuggerSettings"), TEXT("NameForGameView5"), CustomViewNames.GameView5, GEngineIni);
GConfig->GetString(TEXT("GameplayDebuggerSettings"), TEXT("NameForGameView5"), CustomViewNames.GameView5, GEngineIni);
GConfig->GetBool(TEXT("GameplayDebuggerSettings"), TEXT("OverHead"), OverHead, GEngineIni);
GConfig->GetBool(TEXT("GameplayDebuggerSettings"), TEXT("Basic"), Basic, GEngineIni);
GConfig->GetBool(TEXT("GameplayDebuggerSettings"), TEXT("BehaviorTree"), BehaviorTree, GEngineIni);
GConfig->GetBool(TEXT("GameplayDebuggerSettings"), TEXT("EQS"), EQS, GEngineIni);
GConfig->GetBool(TEXT("GameplayDebuggerSettings"), TEXT("EnableEQSOnHUD"), EnableEQSOnHUD, GEngineIni);
GConfig->GetBool(TEXT("GameplayDebuggerSettings"), TEXT("Perception"), Perception, GEngineIni);
GConfig->GetBool(TEXT("GameplayDebuggerSettings"), TEXT("GameView1"), GameView1, GEngineIni);
GConfig->GetBool(TEXT("GameplayDebuggerSettings"), TEXT("GameView2"), GameView2, GEngineIni);
GConfig->GetBool(TEXT("GameplayDebuggerSettings"), TEXT("GameView3"), GameView3, GEngineIni);
GConfig->GetBool(TEXT("GameplayDebuggerSettings"), TEXT("GameView4"), GameView4, GEngineIni);
GConfig->GetBool(TEXT("GameplayDebuggerSettings"), TEXT("GameView5"), GameView5, GEngineIni);
#if ADD_LEVEL_EDITOR_EXTENSIONS
bExtendViewportMenu = false;
GConfig->GetBool(TEXT("GameplayDebuggerSettings"), TEXT("bExtendViewportMenu"), bExtendViewportMenu, GEngineIni);
#endif
}
}
bool VSCheckInstall::checkInstallComplex(bool completeMcf)
{
if (HasAnyFlags(getItemInfo()->getStatus(), UserCore::Item::ItemInfoI::STATUS_INSTALLCOMPLEX) == false)
return false;
auto pItem = getItemInfo();
auto pParent = getParentItemInfo();
if (pParent)
{
if (!pParent->getInstalledModId().isOk() || pParent->getInstalledModId() != pItem->getId())
{
if (completeMcf)
setResult(RES_COMPLETE);
else
setResult(RES_DOWNLOADMISSING);
return true;
}
}
else if (pItem->getInstalledModId().isOk())
{
setResult(RES_COMPLETE);
return true;
}
return false;
}
void UAIPerceptionComponent::CleanUp()
{
if (bCleanedUp == false)
{
UAIPerceptionSystem* AIPerceptionSys = UAIPerceptionSystem::GetCurrent(GetWorld());
if (AIPerceptionSys != nullptr)
{
AIPerceptionSys->UnregisterListener(*this);
AActor* MutableBodyActor = GetMutableBodyActor();
if (MutableBodyActor)
{
AIPerceptionSys->UnregisterSource(*MutableBodyActor);
}
}
if (HasAnyFlags(RF_BeginDestroyed) == false)
{
AActor* Owner = GetOwner();
if (Owner != nullptr)
{
Owner->OnEndPlay.RemoveDynamic(this, &UAIPerceptionComponent::OnOwnerEndPlay);
}
}
bCleanedUp = true;
}
}
void AEQSTestingPawn::UpdateDrawing()
{
#if WITH_EDITORONLY_DATA
if (HasAnyFlags(RF_ClassDefaultObject) == true)
{
return;
}
UBillboardComponent* SpriteComponent = FindComponentByClass<UBillboardComponent>();
if (SpriteComponent != NULL)
{
SpriteComponent->MarkRenderStateDirty();
}
if (EdRenderComp != NULL && EdRenderComp->bVisible)
{
EdRenderComp->MarkRenderStateDirty();
#if WITH_EDITOR
if (GEditor != NULL)
{
GEditor->RedrawLevelEditingViewports();
}
#endif // WITH_EDITOR
}
#endif // WITH_EDITORONLY_DATA
}
void UDeviceProfileManager::SaveProfiles(bool bSaveToDefaults)
{
if( !HasAnyFlags( RF_ClassDefaultObject ) )
{
if(bSaveToDefaults)
{
for (int32 DeviceProfileIndex = 0; DeviceProfileIndex < Profiles.Num(); ++DeviceProfileIndex)
{
UDeviceProfile* CurrentProfile = CastChecked<UDeviceProfile>(Profiles[DeviceProfileIndex]);
CurrentProfile->UpdateDefaultConfigFile();
}
}
else
{
TArray< FString > DeviceProfileMapArray;
for (int32 DeviceProfileIndex = 0; DeviceProfileIndex < Profiles.Num(); ++DeviceProfileIndex)
{
UDeviceProfile* CurrentProfile = CastChecked<UDeviceProfile>(Profiles[DeviceProfileIndex]);
FString DeviceProfileTypeNameCombo = FString::Printf(TEXT("%s,%s"), *CurrentProfile->GetName(), *CurrentProfile->DeviceType);
DeviceProfileMapArray.Add(DeviceProfileTypeNameCombo);
CurrentProfile->SaveConfig(CPF_Config, *DeviceProfileFileName);
}
GConfig->SetArray(TEXT("DeviceProfiles"), TEXT("DeviceProfileNameAndTypes"), DeviceProfileMapArray, DeviceProfileFileName);
GConfig->Flush(false, DeviceProfileFileName);
}
ManagerUpdatedDelegate.Broadcast();
}
}
UEdGraphPin* UEdGraphNode::CreatePin(EEdGraphPinDirection Dir, const FEdGraphPinType& InPinType, const FString& PinName, int32 Index /*= INDEX_NONE*/)
{
UEdGraphPin* NewPin = NewObject<UEdGraphPin>(this);
NewPin->PinName = PinName;
NewPin->Direction = Dir;
NewPin->PinType = InPinType;
NewPin->SetFlags(RF_Transactional);
if (HasAnyFlags(RF_Transient))
{
NewPin->SetFlags(RF_Transient);
}
Modify(false);
if (Pins.IsValidIndex(Index))
{
Pins.Insert(NewPin, Index);
}
else
{
Pins.Add(NewPin);
}
return NewPin;
}
void UModel::PostLoad()
{
Super::PostLoad();
if( FApp::CanEverRender() && !HasAnyFlags(RF_ClassDefaultObject) )
{
UpdateVertices();
}
// If in the editor, initialize each surface to hidden or not depending upon
// whether the poly flag dictates being hidden at editor startup or not
if ( GIsEditor )
{
for ( TArray<FBspSurf>::TIterator SurfIter( Surfs ); SurfIter; ++SurfIter )
{
FBspSurf& CurSurf = *SurfIter;
CurSurf.bHiddenEdTemporary = ( ( CurSurf.PolyFlags & PF_HiddenEd ) != 0 );
CurSurf.bHiddenEdLevel = 0;
}
#if WITH_EDITOR
if (ABrush* Owner = Cast<ABrush>(GetOuter()))
{
OwnerLocationWhenLastBuilt = Owner->GetActorLocation();
OwnerPrepivotWhenLastBuilt = Owner->GetPrePivot();
OwnerScaleWhenLastBuilt = Owner->GetActorScale();
OwnerRotationWhenLastBuilt = -Owner->GetActorRotation();
bCachedOwnerTransformValid = true;
}
#endif
}
}
bool VerifyServiceTask::checkItem()
{
gcException eBadItem(ERR_BADITEM);
gcException eBrchNull(ERR_BADITEM, "Item branch is null");
UserCore::Item::ItemInfo* pItem = getItemInfo();
if (!pItem)
{
onError(eBadItem);
return true;
}
if (!pItem->isDownloadable())
{
finishVerify(UserCore::Misc::VerifyComplete::V_COMPLETE);
return true;
}
if (!pItem->getCurrentBranch())
{
if (HasAnyFlags(pItem->getStatus(), UserCore::Item::ItemInfoI::STATUS_INSTALLED|UserCore::Item::ItemInfoI::STATUS_DOWNLOADING|UserCore::Item::ItemInfoI::STATUS_INSTALLING))
onError(eBrchNull);
else
finishVerify(UserCore::Misc::VerifyComplete::V_RESET);
return true;
}
return false;
}
bool GatherInfoTask::checkNullBranch(UserCore::Item::BranchInfoI* branchInfo)
{
if (branchInfo)
return true;
if (!getUserCore()->getItemManager()->isKnownBranch(getMcfBranch(), getItemId()))
throw gcException(ERR_BADITEM, "Branch is invalid or user doesnt have permissions to install branch.");
if (!m_bFirstTime || HasAnyFlags(m_uiFlags, GI_FLAG_TEST))
throw gcException(ERR_UNSUPPORTEDPLATFORM, 1, "This branch is not supported on this platform");
m_bFirstTime = false;
bool res = false;
if (!m_bCanceled && m_pGIHH)
res = m_pGIHH->showPlatformError();
if (!res)
{
completeStage();
}
else
{
m_uiMcfBranch = MCFBranch::BranchFromInt(0);
checkRequirements();
}
return false;
}
bool UAmethystGameInstance::LoadFrontEndMap(const FString& MapName)
{
bool bSuccess = true;
// if already loaded, do nothing
UWorld* const World = GetWorld();
if (World)
{
FString const CurrentMapName = *World->PersistentLevel->GetOutermost()->GetName();
//if (MapName.Find(TEXT("Highrise")) != -1)
if (CurrentMapName == MapName)
{
return bSuccess;
}
}
FString Error;
EBrowseReturnVal::Type BrowseRet = EBrowseReturnVal::Failure;
FURL URL(
*FString::Printf(TEXT("%s"), *MapName)
);
if (URL.Valid && !HasAnyFlags(RF_ClassDefaultObject)) //CastChecked<UEngine>() will fail if using Default__AmethystGameInstance, so make sure that we're not default
{
BrowseRet = GetEngine()->Browse(*WorldContext, URL, Error);
// Handle failure.
if (BrowseRet != EBrowseReturnVal::Success)
{
UE_LOG(LogLoad, Fatal, TEXT("%s"), *FString::Printf(TEXT("Failed to enter %s: %s. Please check the log for errors."), *MapName, *Error));
bSuccess = false;
}
}
return bSuccess;
}
void UNavArea::PostLoad()
{
Super::PostLoad();
if (HasAnyFlags(RF_ClassDefaultObject)
#if WITH_HOT_RELOAD
&& !GIsHotReload
#endif // WITH_HOT_RELOAD
)
{
UNavigationSystem::RequestAreaRegistering(GetClass());
}
if (!SupportedAgents.IsInitialized())
{
SupportedAgents.bSupportsAgent0 = bSupportsAgent0;
SupportedAgents.bSupportsAgent1 = bSupportsAgent1;
SupportedAgents.bSupportsAgent2 = bSupportsAgent2;
SupportedAgents.bSupportsAgent3 = bSupportsAgent3;
SupportedAgents.bSupportsAgent4 = bSupportsAgent4;
SupportedAgents.bSupportsAgent5 = bSupportsAgent5;
SupportedAgents.bSupportsAgent6 = bSupportsAgent6;
SupportedAgents.bSupportsAgent7 = bSupportsAgent7;
SupportedAgents.bSupportsAgent8 = bSupportsAgent8;
SupportedAgents.bSupportsAgent9 = bSupportsAgent9;
SupportedAgents.bSupportsAgent10 = bSupportsAgent10;
SupportedAgents.bSupportsAgent11 = bSupportsAgent11;
SupportedAgents.bSupportsAgent12 = bSupportsAgent12;
SupportedAgents.bSupportsAgent13 = bSupportsAgent13;
SupportedAgents.bSupportsAgent14 = bSupportsAgent14;
SupportedAgents.bSupportsAgent15 = bSupportsAgent15;
SupportedAgents.MarkInitialized();
}
}
void UDeviceProfileManager::SaveProfiles()
{
if( !HasAnyFlags( RF_ClassDefaultObject ) )
{
InternalSaveProfiles();
}
}
void TBIUpdateMenu::calcUpdates()
{
UserCore::UserI* user = GetUserCore();
if (!user)
{
messageCount = 0;
updateCount = 0;
cartCount = 0;
}
else
{
messageCount = user->getPmCount();
updateCount = user->getUpCount();
cartCount = user->getCartCount();
}
gameUpdateCount = 0;
modUpdateCount = 0;
if (!m_pItemManager && GetUserCore())
m_pItemManager = GetUserCore()->getItemManager();
if (!m_pItemManager)
return;
std::vector<UserCore::Item::ItemInfoI*> gList;
m_pItemManager->getGameList(gList);
for (size_t x=0; x<gList.size(); x++)
{
if (HasAnyFlags(gList[x]->getStatus(), UserCore::Item::ItemInfoI::STATUS_UPDATEAVAL))
gameUpdateCount++;
std::vector<UserCore::Item::ItemInfoI*> mList;
m_pItemManager->getModList(gList[x]->getId(), mList);
for (size_t y=0; y<mList.size(); y++)
{
if (HasAnyFlags(mList[y]->getStatus(), UserCore::Item::ItemInfoI::STATUS_UPDATEAVAL))
gameUpdateCount++;
}
}
uint32 numUpdates = messageCount + updateCount + gameUpdateCount + modUpdateCount;
m_szMenuName = gcWString(L"{0} ({1})", Managers::GetString(L"#TB_STATUS"), numUpdates);
}
void USpriterProject::PostInitProperties()
{
if (!HasAnyFlags(RF_ClassDefaultObject))
{
AssetImportData = NewObject<UAssetImportData>(this, TEXT("AssetImportData"));
}
Super::PostInitProperties();
}
void UParticleModuleVelocity::PostInitProperties()
{
Super::PostInitProperties();
if (!HasAnyFlags(RF_ClassDefaultObject | RF_NeedLoad))
{
InitializeDefaults();
}
}
UBPDownloader::UBPDownloader(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
if (HasAnyFlags(RF_ClassDefaultObject) == false)
{
AddToRoot();
}
}
UJavascriptOutputDevice::UJavascriptOutputDevice(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
if (!HasAnyFlags(RF_ClassDefaultObject))
{
OutputDevice = MakeShareable(new FJavascriptOutputDevice(this));
}
}
void UUnrealEdOptions::PostInitProperties()
{
Super::PostInitProperties();
if (!HasAnyFlags(RF_ClassDefaultObject | RF_NeedLoad))
{
EditorKeyBindings = NewObject<UUnrealEdKeyBindings>(this, FName("EditorKeyBindingsInst"));
}
}
void USoundCue::PostInitProperties()
{
Super::PostInitProperties();
if (!HasAnyFlags(RF_ClassDefaultObject | RF_NeedLoad))
{
CreateGraph();
}
}
void UScriptContext::PostInitProperties()
{
Super::PostInitProperties();
if (!HasAnyFlags(RF_ClassDefaultObject))
{
auto ContextOwner = GetOuter();
if (ContextOwner && !ContextOwner->HasAnyFlags(RF_ClassDefaultObject))
{
auto ScriptClass = UScriptBlueprintGeneratedClass::GetScriptGeneratedClass(ContextOwner->GetClass());
if (ScriptClass)
{
Context = FScriptContextBase::CreateContext(ScriptClass->SourceCode, ScriptClass, ContextOwner);
}
}
}
}