void UEdGraphNode::PostLoad()
{
Super::PostLoad();
// Create Guid if not present (and not CDO)
if(!NodeGuid.IsValid() && !IsTemplate() && GetLinker() && GetLinker()->IsPersistent() && GetLinker()->IsLoading())
{
UE_LOG(LogBlueprint, Warning, TEXT("Node '%s' missing NodeGuid."), *GetPathName());
// Generate new one
CreateNewGuid();
}
// Duplicating a Blueprint needs to have a new Node Guid generated, which was not occuring before this version
if(GetLinkerUE4Version() < VER_UE4_POST_DUPLICATE_NODE_GUID)
{
// Generate new one
CreateNewGuid();
}
// Moving to the new style comments requires conversion to preserve previous state
if(GetLinkerUE4Version() < VER_UE4_GRAPH_INTERACTIVE_COMMENTBUBBLES)
{
bCommentBubbleVisible = !NodeComment.IsEmpty();
}
}
void UActorComponent::PostLoad()
{
Super::PostLoad();
if (GetLinkerUE4Version() < VER_UE4_ACTOR_COMPONENT_CREATION_METHOD)
{
if (IsTemplate())
{
CreationMethod = EComponentCreationMethod::Native;
}
else if (bCreatedByConstructionScript_DEPRECATED)
{
CreationMethod = EComponentCreationMethod::SimpleConstructionScript;
}
else if (bInstanceComponent_DEPRECATED)
{
CreationMethod = EComponentCreationMethod::Instance;
}
if (CreationMethod == EComponentCreationMethod::SimpleConstructionScript)
{
UBlueprintGeneratedClass* Class = CastChecked<UBlueprintGeneratedClass>(GetOuter()->GetClass());
while (Class)
{
USimpleConstructionScript* SCS = Class->SimpleConstructionScript;
if (SCS != nullptr && SCS->FindSCSNode(GetFName()))
{
break;
}
else
{
Class = Cast<UBlueprintGeneratedClass>(Class->GetSuperClass());
if (Class == nullptr)
{
CreationMethod = EComponentCreationMethod::UserConstructionScript;
}
}
}
}
}
if (CreationMethod == EComponentCreationMethod::SimpleConstructionScript)
{
if ((GetLinkerUE4Version() < VER_UE4_TRACK_UCS_MODIFIED_PROPERTIES) && !HasAnyFlags(RF_ClassDefaultObject))
{
DetermineUCSModifiedProperties();
}
}
else
{
// For a brief period of time we were inadvertently storing these for all components, need to clear it out
UCSModifiedProperties.Empty();
}
}
void UPhysicsConstraintComponent::PostLoad()
{
Super::PostLoad();
// Fix old content that used a ConstraintSetup
if ( GetLinkerUE4Version() < VER_UE4_ALL_PROPS_TO_CONSTRAINTINSTANCE && (ConstraintSetup_DEPRECATED != NULL) )
{
// Will have copied from setup into DefaultIntance inside
ConstraintInstance.CopyConstraintParamsFrom(&ConstraintSetup_DEPRECATED->DefaultInstance);
ConstraintSetup_DEPRECATED = NULL;
}
if (GetLinkerUE4Version() < VER_UE4_SOFT_CONSTRAINTS_USE_MASS)
{
//In previous versions the mass was placed into the spring constant. This is correct because you use different springs for different mass - however, this makes tuning hard
//We now multiply mass into the spring constant. To fix old data we use CalculateMass which is not perfect but close (within 0.1kg)
//We also use the primitive body instance directly for determining if simulated - this is potentially wrong for fixed bones in skeletal mesh, but it's much more likely right (in skeletal case we don't have access to bodies to check)
UPrimitiveComponent * Primitive1 = GetComponentInternal(EConstraintFrame::Frame1);
UPrimitiveComponent * Primitive2 = GetComponentInternal(EConstraintFrame::Frame2);
int NumDynamic = 0;
float TotalMass = 0.f;
if (Primitive1 && Primitive1->BodyInstance.bSimulatePhysics)
{
FName BoneName = ConstraintInstance.ConstraintBone1;
++NumDynamic;
TotalMass += Primitive1->CalculateMass(BoneName);
}
if (Primitive2 && Primitive2->BodyInstance.bSimulatePhysics)
{
FName BoneName = ConstraintInstance.ConstraintBone2;
++NumDynamic;
TotalMass += Primitive2->CalculateMass(BoneName);
}
if ( (NumDynamic > 0) && (TotalMass > 0) ) //we don't support cases where both constrained bodies are static or NULL, but add this anyway to avoid crash
{
float AverageMass = TotalMass / NumDynamic;
ConstraintInstance.LinearLimitStiffness /= AverageMass;
ConstraintInstance.SwingLimitStiffness /= AverageMass;
ConstraintInstance.TwistLimitStiffness /= AverageMass;
ConstraintInstance.LinearLimitDamping /= AverageMass;
ConstraintInstance.SwingLimitDamping /= AverageMass;
ConstraintInstance.TwistLimitDamping /= AverageMass;
}
}
}
void UAnimSequenceBase::PostLoad()
{
Super::PostLoad();
// Convert Notifies to new data
if( GIsEditor && Notifies.Num() > 0 )
{
if(GetLinkerUE4Version() < VER_UE4_CLEAR_NOTIFY_TRIGGERS)
{
for(FAnimNotifyEvent Notify : Notifies)
{
if(Notify.Notify)
{
// Clear end triggers for notifies that are not notify states
Notify.EndTriggerTimeOffset = 0.0f;
}
}
}
}
// Ensure notifies are sorted.
SortNotifies();
#if WITH_EDITOR
InitializeNotifyTrack();
UpdateAnimNotifyTrackCache();
#endif
if(USkeleton* Skeleton = GetSkeleton())
{
// Fix up the existing curves to work with smartnames
if(GetLinkerUE4Version() < VER_UE4_SKELETON_ADD_SMARTNAMES)
{
// Get the name mapping object for curves
FSmartNameMapping* NameMapping = Skeleton->SmartNames.GetContainer(USkeleton::AnimCurveMappingName);
for(FFloatCurve& Curve : RawCurveData.FloatCurves)
{
// Add the names of the curves into the smartname mapping and store off the curve uid which will be saved next time the sequence saves.
NameMapping->AddOrFindName(Curve.LastObservedName, Curve.CurveUid);
}
}
else
{
VerifyCurveNames<FFloatCurve>(Skeleton, USkeleton::AnimCurveMappingName, RawCurveData.FloatCurves);
}
#if WITH_EDITOR
VerifyCurveNames<FTransformCurve>(Skeleton, USkeleton::AnimTrackCurveMappingName, RawCurveData.TransformCurves);
#endif
}
}
void UEditableTextBox::PostLoad()
{
Super::PostLoad();
if ( GetLinkerUE4Version() < VER_UE4_DEPRECATE_UMG_STYLE_ASSETS )
{
if ( Style_DEPRECATED != nullptr )
{
const FEditableTextBoxStyle* StylePtr = Style_DEPRECATED->GetStyle<FEditableTextBoxStyle>();
if ( StylePtr != nullptr )
{
WidgetStyle = *StylePtr;
}
Style_DEPRECATED = nullptr;
}
}
if (GetLinkerUE4Version() < VER_UE4_DEPRECATE_UMG_STYLE_OVERRIDES)
{
if (Font_DEPRECATED.HasValidFont())
{
WidgetStyle.Font = Font_DEPRECATED;
Font_DEPRECATED = FSlateFontInfo();
}
WidgetStyle.Padding = Padding_DEPRECATED;
Padding_DEPRECATED = FMargin(0);
if (ForegroundColor_DEPRECATED != FLinearColor::Black)
{
WidgetStyle.ForegroundColor = ForegroundColor_DEPRECATED;
ForegroundColor_DEPRECATED = FLinearColor::Black;
}
if (BackgroundColor_DEPRECATED != FLinearColor::White)
{
WidgetStyle.BackgroundColor = BackgroundColor_DEPRECATED;
BackgroundColor_DEPRECATED = FLinearColor::White;
}
if (ReadOnlyForegroundColor_DEPRECATED != FLinearColor::Black)
{
WidgetStyle.ReadOnlyForegroundColor = ReadOnlyForegroundColor_DEPRECATED;
ReadOnlyForegroundColor_DEPRECATED = FLinearColor::Black;
}
}
}
void UScrollBox::PostLoad()
{
Super::PostLoad();
if ( GetLinkerUE4Version() < VER_UE4_DEPRECATE_UMG_STYLE_ASSETS )
{
if ( Style_DEPRECATED != nullptr )
{
const FScrollBoxStyle* StylePtr = Style_DEPRECATED->GetStyle<FScrollBoxStyle>();
if ( StylePtr != nullptr )
{
WidgetStyle = *StylePtr;
}
Style_DEPRECATED = nullptr;
}
if ( BarStyle_DEPRECATED != nullptr )
{
const FScrollBarStyle* StylePtr = BarStyle_DEPRECATED->GetStyle<FScrollBarStyle>();
if ( StylePtr != nullptr )
{
WidgetBarStyle = *StylePtr;
}
BarStyle_DEPRECATED = nullptr;
}
}
}
void ASpotLight::LoadedFromAnotherClass(const FName& OldClassName)
{
Super::LoadedFromAnotherClass(OldClassName);
if(GetLinkerUE4Version() < VER_UE4_REMOVE_LIGHT_MOBILITY_CLASSES)
{
static FName SpotLightStatic_NAME(TEXT("SpotLightStatic"));
static FName SpotLightMovable_NAME(TEXT("SpotLightMovable"));
static FName SpotLightStationary_NAME(TEXT("SpotLightStationary"));
check(GetLightComponent() != NULL);
if(OldClassName == SpotLightStatic_NAME)
{
GetLightComponent()->Mobility = EComponentMobility::Static;
}
else if(OldClassName == SpotLightMovable_NAME)
{
GetLightComponent()->Mobility = EComponentMobility::Movable;
}
else if(OldClassName == SpotLightStationary_NAME)
{
GetLightComponent()->Mobility = EComponentMobility::Stationary;
}
}
}
void UBorder::PostLoad()
{
Super::PostLoad();
if ( GetLinkerUE4Version() < VER_UE4_DEPRECATE_UMG_STYLE_ASSETS && Brush_DEPRECATED != nullptr )
{
Background = Brush_DEPRECATED->Brush;
Brush_DEPRECATED = nullptr;
}
if ( GetChildrenCount() > 0 )
{
//TODO UMG Pre-Release Upgrade, now have slots of their own. Convert existing slot to new slot.
if ( UPanelSlot* PanelSlot = GetContentSlot() )
{
UBorderSlot* BorderSlot = Cast<UBorderSlot>(PanelSlot);
if ( BorderSlot == NULL )
{
BorderSlot = NewObject<UBorderSlot>(this);
BorderSlot->Content = GetContentSlot()->Content;
BorderSlot->Content->Slot = BorderSlot;
Slots[0] = BorderSlot;
}
}
}
}
void USkeletalMeshComponent::LoadedFromAnotherClass(const FName& OldClassName)
{
Super::LoadedFromAnotherClass(OldClassName);
if(GetLinkerUE4Version() < VER_UE4_REMOVE_SINGLENODEINSTANCE)
{
static FName SingleAnimSkeletalComponent_NAME(TEXT("SingleAnimSkeletalComponent"));
if(OldClassName == SingleAnimSkeletalComponent_NAME)
{
SetAnimationMode(EAnimationMode::Type::AnimationSingleNode);
// support old compatibility code that changed variable name
if (SequenceToPlay_DEPRECATED!=NULL && AnimToPlay_DEPRECATED== NULL)
{
AnimToPlay_DEPRECATED = SequenceToPlay_DEPRECATED;
SequenceToPlay_DEPRECATED = NULL;
}
AnimationData.AnimToPlay = AnimToPlay_DEPRECATED;
AnimationData.bSavedLooping = bDefaultLooping_DEPRECATED;
AnimationData.bSavedPlaying = bDefaultPlaying_DEPRECATED;
AnimationData.SavedPosition = DefaultPosition_DEPRECATED;
AnimationData.SavedPlayRate = DefaultPlayRate_DEPRECATED;
MarkPackageDirty();
}
}
}
/**
* Called after this UObject has been serialized
*/
void ULightComponent::PostLoad()
{
Super::PostLoad();
if (LightFunctionMaterial && HasStaticLighting())
{
// Light functions can only be used on dynamic lights
LightFunctionMaterial = NULL;
}
PreviewShadowMapChannel = ShadowMapChannel;
Intensity = FMath::Max(0.0f, Intensity);
if (GetLinkerUE4Version() < VER_UE4_LIGHTCOMPONENT_USE_IES_TEXTURE_MULTIPLIER_ON_NON_IES_BRIGHTNESS)
{
if(IESTexture)
{
UTextureLightProfile* IESTextureObject = Cast<UTextureLightProfile>(IESTexture);
if(IESTextureObject)
{
Intensity /= IESTextureObject->TextureMultiplier; // Previous version didn't apply IES texture multiplier, so cancel out
IESBrightnessScale = FMath::Pow(IESBrightnessScale, 2.2f); // Previous version applied 2.2 gamma to brightness scale
IESBrightnessScale /= IESTextureObject->TextureMultiplier; // Previous version didn't apply IES texture multiplier, so cancel out
}
}
}
if (HasStaticShadowing() && !HasStaticLighting())
{
BeginInitResource(&StaticShadowDepthMap);
}
}
void UButton::PostLoad()
{
Super::PostLoad();
if ( GetChildrenCount() > 0 )
{
//TODO UMG Pre-Release Upgrade, now buttons have slots of their own. Convert existing slot to new slot.
if ( UPanelSlot* PanelSlot = GetContentSlot() )
{
UButtonSlot* ButtonSlot = Cast<UButtonSlot>(PanelSlot);
if ( ButtonSlot == NULL )
{
ButtonSlot = NewObject<UButtonSlot>(this);
ButtonSlot->Content = GetContentSlot()->Content;
ButtonSlot->Content->Slot = ButtonSlot;
Slots[0] = ButtonSlot;
}
}
}
if( GetLinkerUE4Version() < VER_UE4_DEPRECATE_UMG_STYLE_ASSETS && Style_DEPRECATED != nullptr )
{
const FButtonStyle* StylePtr = Style_DEPRECATED->GetStyle<FButtonStyle>();
if(StylePtr != nullptr)
{
WidgetStyle = *StylePtr;
}
Style_DEPRECATED = nullptr;
}
}
void UWidgetBlueprint::PostLoad()
{
Super::PostLoad();
WidgetTree->ForEachWidget([&] (UWidget* Widget) {
Widget->ConnectEditorData();
});
if( GetLinkerUE4Version() < VER_UE4_FIXUP_WIDGET_ANIMATION_CLASS )
{
// Fixup widget animiations.
for( auto& OldAnim : AnimationData_DEPRECATED )
{
FName AnimName = OldAnim.MovieScene->GetFName();
// Rename the old movie scene so we can reuse the name
OldAnim.MovieScene->Rename( *MakeUniqueObjectName( this, UMovieScene::StaticClass(), "MovieScene").ToString(), nullptr, REN_ForceNoResetLoaders | REN_DontCreateRedirectors | REN_DoNotDirty | REN_NonTransactional);
UWidgetAnimation* NewAnimation = NewObject<UWidgetAnimation>(this, AnimName, RF_Transactional);
OldAnim.MovieScene->Rename(*AnimName.ToString(), NewAnimation, REN_ForceNoResetLoaders | REN_DontCreateRedirectors | REN_DoNotDirty | REN_NonTransactional );
NewAnimation->MovieScene = OldAnim.MovieScene;
NewAnimation->AnimationBindings = OldAnim.AnimationBindings;
Animations.Add( NewAnimation );
}
AnimationData_DEPRECATED.Empty();
}
if ( GetLinkerUE4Version() < VER_UE4_RENAME_WIDGET_VISIBILITY )
{
static const FName Visiblity(TEXT("Visiblity"));
static const FName Visibility(TEXT("Visibility"));
for ( FDelegateEditorBinding& Binding : Bindings )
{
if ( Binding.PropertyName == Visiblity )
{
Binding.PropertyName = Visibility;
}
}
}
}
void UMaterialExpressionLandscapeLayerSwitch::PostLoad()
{
Super::PostLoad();
if (GetLinkerUE4Version() < VER_UE4_FIXUP_TERRAIN_LAYER_NODES)
{
UpdateParameterGuid(true, true);
}
}
void UCurveFloat::PostLoad()
{
Super::PostLoad();
if(GetLinkerUE4Version() < VER_UE4_UCURVE_USING_RICHCURVES)
{
FRichCurve::ConvertInterpCurveFloat(FloatKeys_DEPRECATED, FloatCurve);
}
}
void UK2Node_InputAxisEvent::PostLoad()
{
Super::PostLoad();
if (GetLinkerUE4Version() < VER_UE4_BLUEPRINT_INPUT_BINDING_OVERRIDES)
{
// Don't change existing behaviors
bOverrideParentBinding = false;
}
}
void UAnimGraphNode_SpringBone::PostLoad()
{
Super::PostLoad();
if (GetLinkerUE4Version() < VER_UE4_REPLACE_SPRING_NOZ_PROPERTY)
{
//Fix up z translation from old NoZSpring property
Node.bTranslateZ = !Node.bNoZSpring_DEPRECATED;
}
}
void UImage::PostLoad()
{
Super::PostLoad();
if ( GetLinkerUE4Version() < VER_UE4_DEPRECATE_UMG_STYLE_ASSETS && Image_DEPRECATED != nullptr )
{
Brush = Image_DEPRECATED->Brush;
Image_DEPRECATED = nullptr;
}
}
void UTextBlock::PostLoad()
{
Super::PostLoad();
if ( GetLinkerUE4Version() < VER_UE4_DEPRECATE_UMG_STYLE_ASSETS )
{
if ( Style_DEPRECATED != nullptr )
{
Style_DEPRECATED = nullptr;
}
}
}
void APhysicsConstraintActor::PostLoad()
{
Super::PostLoad();
// Copy 'actors to constrain' into component
if (GetLinkerUE4Version() < VER_UE4_ALL_PROPS_TO_CONSTRAINTINSTANCE && ConstraintComp != NULL)
{
ConstraintComp->ConstraintActor1 = ConstraintActor1_DEPRECATED;
ConstraintComp->ConstraintActor2 = ConstraintActor2_DEPRECATED;
ConstraintComp->ConstraintInstance.bDisableCollision = bDisableCollision_DEPRECATED;
}
}
void UCircularThrobber::PostLoad()
{
Super::PostLoad();
if ( GetLinkerUE4Version() < VER_UE4_DEPRECATE_UMG_STYLE_ASSETS )
{
if ( PieceImage_DEPRECATED != nullptr )
{
Image = PieceImage_DEPRECATED->Brush;
PieceImage_DEPRECATED = nullptr;
}
}
}
void UPhysicalMaterial::PostLoad()
{
Super::PostLoad();
// we're removing physical material property, so convert to Material type
if (GetLinkerUE4Version() < VER_UE4_REMOVE_PHYSICALMATERIALPROPERTY)
{
if (PhysicalMaterialProperty)
{
SurfaceType = PhysicalMaterialProperty->ConvertToSurfaceType();
}
}
}
void UMultiLineEditableText::PostLoad()
{
Super::PostLoad();
if (GetLinkerUE4Version() < VER_UE4_DEPRECATE_UMG_STYLE_OVERRIDES)
{
if (Font_DEPRECATED.HasValidFont())
{
WidgetStyle.Font = Font_DEPRECATED;
Font_DEPRECATED = FSlateFontInfo();
}
}
}
void ATriggerVolume::LoadedFromAnotherClass(const FName& OldClassName)
{
Super::LoadedFromAnotherClass(OldClassName);
if(GetLinkerUE4Version() < VER_UE4_REMOVE_DYNAMIC_VOLUME_CLASSES)
{
static FName DynamicTriggerVolume_NAME(TEXT("DynamicTriggerVolume"));
if(OldClassName == DynamicTriggerVolume_NAME)
{
GetBrushComponent()->Mobility = EComponentMobility::Movable;
}
}
}
void UPhysicsConstraintTemplate::PostLoad()
{
Super::PostLoad();
//Check the version
if ( GetLinkerUE4Version() < VER_UE4_ANGULAR_CONSTRAINT_OPTIONS )
{
if ( DefaultInstance.bSwingLimited_DEPRECATED )
{
if (DefaultInstance.Swing1LimitAngle < RB_MinAngleToLockDOF)
{
DefaultInstance.AngularSwing1Motion = ACM_Locked;
}
else
{
DefaultInstance.AngularSwing1Motion = ACM_Limited;
}
if (DefaultInstance.Swing2LimitAngle < RB_MinAngleToLockDOF)
{
DefaultInstance.AngularSwing2Motion = ACM_Locked;
}
else
{
DefaultInstance.AngularSwing2Motion = ACM_Limited;
}
}
else
{
DefaultInstance.AngularSwing1Motion = ACM_Free;
DefaultInstance.AngularSwing2Motion = ACM_Free;
}
if ( DefaultInstance.bTwistLimited_DEPRECATED )
{
if (DefaultInstance.TwistLimitAngle < RB_MinAngleToLockDOF)
{
DefaultInstance.AngularTwistMotion = ACM_Locked;
}
else
{
DefaultInstance.AngularTwistMotion = ACM_Limited;
}
}
else
{
DefaultInstance.AngularTwistMotion = ACM_Free;
}
}
}
void UCameraComponent::PostLoad()
{
Super::PostLoad();
const int32 LinkerUE4Ver = GetLinkerUE4Version();
if (LinkerUE4Ver < VER_UE4_RENAME_CAMERA_COMPONENT_VIEW_ROTATION)
{
bUsePawnControlRotation = bUseControllerViewRotation_DEPRECATED;
}
// Init deprecated var, for old code that may refer to it.
SetDeprecatedControllerViewRotation(*this, bUsePawnControlRotation);
}
void UTextRenderComponent::PostLoad()
{
// Try and fix up assets created before the vertical alignment fix was implemented. Because we didn't flag that
// fix with its own version, use the version number closest to that CL
if (GetLinkerUE4Version() < VER_UE4_PACKAGE_REQUIRES_LOCALIZATION_GATHER_FLAGGING)
{
float Offset = CalculateVerticalAlignmentOffset(*Text.ToString(), Font, XScale, YScale, HorizSpacingAdjust, VerticalAlignment);
FTransform RelativeTransform = GetRelativeTransform();
FTransform CorrectionLeft = FTransform::Identity;
FTransform CorrectionRight = FTransform::Identity;
CorrectionLeft.SetTranslation(FVector(0.0f, 0.0f, -Offset));
CorrectionRight.SetTranslation(FVector(0.0f, 0.0f, Offset));
SetRelativeTransform(CorrectionLeft * RelativeTransform * CorrectionRight);
}
if (GetLinkerUE4Version() < VER_UE4_ADD_TEXT_COMPONENT_VERTICAL_ALIGNMENT)
{
VerticalAlignment = EVRTA_QuadTop;
}
if( GetLinkerUE4Version() < VER_UE4_TEXT_RENDER_COMPONENTS_WORLD_SPACE_SIZING )
{
if( Font )
{
WorldSize = Font->GetMaxCharHeight();
InvDefaultSize = 1.0f / WorldSize;
}
else
{
//Just guess I suppose? If there is no font then there's no text to break so it's ok.
WorldSize = 30.0f;
InvDefaultSize = 1.0f / 30.0f;
}
}
Super::PostLoad();
}
void ULevelStreaming::PostLoad()
{
Super::PostLoad();
const bool PIESession = GetWorld()->WorldType == EWorldType::PIE || GetOutermost()->HasAnyPackageFlags(PKG_PlayInEditor);
// If this streaming level was saved with a short package name, try to convert it to a long package name
if ( !PIESession && PackageName_DEPRECATED != NAME_None )
{
const FString DeprecatedPackageNameString = PackageName_DEPRECATED.ToString();
if ( FPackageName::IsShortPackageName(PackageName_DEPRECATED) == false )
{
// Convert the FName reference to a TAssetPtr, then broadcast that we loaded a reference
// so this reference is gathered by the cooker without having to resave the package.
SetWorldAssetByPackageName(PackageName_DEPRECATED);
FCoreUObjectDelegates::StringAssetReferenceLoaded.ExecuteIfBound(WorldAsset.ToStringReference().ToString());
}
else
{
UE_LOG(LogLevelStreaming, Display, TEXT("Invalid streaming level package name (%s). Only long package names are supported. This streaming level may not load or save properly."), *DeprecatedPackageNameString);
}
}
if ( !PIESession && !WorldAsset.IsNull() )
{
const FString WorldPackageName = GetWorldAssetPackageName();
if (FPackageName::DoesPackageExist(WorldPackageName) == false)
{
UE_LOG(LogLevelStreaming, Display, TEXT("Failed to find streaming level package file: %s. This streaming level may not load or save properly."), *WorldPackageName);
#if WITH_EDITOR
if (GIsEditor)
{
// Launch notification to inform user of default change
FFormatNamedArguments Args;
Args.Add(TEXT("PackageName"), FText::FromString(WorldPackageName));
FNotificationInfo Info(FText::Format(LOCTEXT("LevelStreamingFailToStreamLevel", "Failed to find streamed level {PackageName}, please fix the reference to it in the Level Browser"), Args));
Info.ExpireDuration = 7.0f;
FSlateNotificationManager::Get().AddNotification(Info);
}
#endif // WITH_EDITOR
}
}
if (GetLinkerUE4Version() < VER_UE4_LEVEL_STREAMING_DRAW_COLOR_TYPE_CHANGE)
{
LevelColor = DrawColor_DEPRECATED;
}
}
void USoundBase::PostLoad()
{
Super::PostLoad();
const int32 LinkerUE4Version = GetLinkerUE4Version();
if (LinkerUE4Version < VER_UE4_SOUND_CONCURRENCY_PACKAGE)
{
bOverrideConcurrency = true;
ConcurrencyOverrides.bLimitToOwner = false;
ConcurrencyOverrides.MaxCount = FMath::Max(MaxConcurrentPlayCount_DEPRECATED, 1);
ConcurrencyOverrides.ResolutionRule = MaxConcurrentResolutionRule_DEPRECATED;
ConcurrencyOverrides.VolumeScale = 1.0f;
}
}
void UProjectileMovementComponent::PostLoad()
{
Super::PostLoad();
const int32 LinkerUE4Ver = GetLinkerUE4Version();
if (LinkerUE4Ver < VER_UE4_REFACTOR_PROJECTILE_MOVEMENT)
{
// Old code used to treat Bounciness as Friction as well.
Friction = FMath::Clamp(1.f - Bounciness, 0.f, 1.f);
// Old projectiles probably don't want to use this behavior by default.
bInitialVelocityInLocalSpace = false;
}
}
void ANavigationData::PostLoad()
{
Super::PostLoad();
if ((GetLinkerUE4Version() < VER_UE4_ADD_MODIFIERS_RUNTIME_GENERATION) &&
(RuntimeGeneration == ERuntimeGenerationType::LegacyGeneration))
{
RuntimeGeneration = bRebuildAtRuntime_DEPRECATED ? ERuntimeGenerationType::Dynamic : ERuntimeGenerationType::Static;
}
InstantiateAndRegisterRenderingComponent();
CachedWorld = GetWorld();
bNetLoadOnClient = (*GEngine->NavigationSystemClass != nullptr) && (GEngine->NavigationSystemClass->GetDefaultObject<UNavigationSystem>()->ShouldLoadNavigationOnClient(this));
}
