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)); }