void UUnrealEdEngine::Cleanse( bool ClearSelection, bool Redraw, const FText& Reason )
{
if (GIsRunning)
{
FMessageLog("MapCheck").NewPage(LOCTEXT("MapCheck", "Map Check"));
FMessageLog("LightingResults").NewPage(LOCTEXT("LightingBuildNewLogPage", "Lighting Build"));
FStatsViewerModule& StatsViewerModule = FModuleManager::Get().LoadModuleChecked<FStatsViewerModule>(TEXT("StatsViewer"));
StatsViewerModule.Clear();
}
Super::Cleanse( ClearSelection, Redraw, Reason );
}
bool UPagedVolumeComponent::SetPagedVolume(UVoreealPagedVolume* NewVolume)
{
if (NewVolume == Volume && NewVolume == nullptr)
return false;
AActor* Owner = GetOwner();
if (!AreDynamicDataChangesAllowed() && Owner != NULL)
{
FMessageLog("PIE").Warning(FText::Format(
FText::FromString(TEXT("Calling SetPagedVolume on '{0}' but Mobility is Static.")),
FText::FromString(GetPathName())));
return false;
}
Volume = NewVolume;
// If there were a volume before we call then we force gc
UWorld* World = GetWorld();
if (World)
{
World->ForceGarbageCollection(true);
}
return true;
}
void AController::Possess(APawn* InPawn)
{
if (!HasAuthority())
{
FMessageLog("PIE").Warning(FText::Format(
LOCTEXT("ControllerPossessAuthorityOnly", "Possess function should only be used by the network authority for {0}"),
FText::FromName(GetFName())
));
return;
}
REDIRECT_OBJECT_TO_VLOG(InPawn, this);
if (InPawn != NULL)
{
if (GetPawn() && GetPawn() != InPawn)
{
UnPossess();
}
if (InPawn->Controller != NULL)
{
InPawn->Controller->UnPossess();
}
InPawn->PossessedBy(this);
SetPawn(InPawn);
// update rotation to match possessed pawn's rotation
SetControlRotation( Pawn->GetActorRotation() );
Pawn->Restart();
}
}
bool FPerforceSourceControlLabel::GetFileRevisions( const TArray<FString>& InFiles, TArray< TSharedRef<ISourceControlRevision, ESPMode::ThreadSafe> >& OutRevisions ) const
{
bool bCommandOK = false;
FPerforceSourceControlModule& PerforceSourceControl = FModuleManager::LoadModuleChecked<FPerforceSourceControlModule>("PerforceSourceControl");
FScopedPerforceConnection ScopedConnection(EConcurrency::Synchronous, PerforceSourceControl.AccessSettings().GetConnectionInfo());
if(ScopedConnection.IsValid())
{
FPerforceConnection& Connection = ScopedConnection.GetConnection();
FP4RecordSet Records;
TArray<FString> Parameters;
TArray<FText> ErrorMessages;
for(auto Iter(InFiles.CreateConstIterator()); Iter; Iter++)
{
Parameters.Add(*Iter + TEXT("@") + Name);
}
bool bConnectionDropped = false;
bCommandOK = Connection.RunCommand(TEXT("files"), Parameters, Records, ErrorMessages, FOnIsCancelled(), bConnectionDropped);
if(bCommandOK)
{
ParseFilesResults(Records, OutRevisions, Connection.ClientRoot);
}
else
{
// output errors if any
for (int32 ErrorIndex = 0; ErrorIndex < ErrorMessages.Num(); ++ErrorIndex)
{
FMessageLog("SourceControl").Error(ErrorMessages[ErrorIndex]);
}
}
}
return bCommandOK;
}
bool FPerforceSourceControlLabel::Sync( const TArray<FString>& InFilenames ) const
{
bool bCommandOK = false;
FPerforceSourceControlModule& PerforceSourceControl = FModuleManager::LoadModuleChecked<FPerforceSourceControlModule>("PerforceSourceControl");
FScopedPerforceConnection ScopedConnection(EConcurrency::Synchronous, PerforceSourceControl.AccessSettings().GetConnectionInfo());
if(ScopedConnection.IsValid())
{
FPerforceConnection& Connection = ScopedConnection.GetConnection();
FP4RecordSet Records;
TArray<FText> ErrorMessages;
TArray<FString> Parameters;
for(const auto& Filename : InFilenames)
{
Parameters.Add(Filename + TEXT("@") + Name);
}
bool bConnectionDropped = false;
bCommandOK = Connection.RunCommand(TEXT("sync"), Parameters, Records, ErrorMessages, FOnIsCancelled(), bConnectionDropped);
if(!bCommandOK)
{
// output errors if any
for (int32 ErrorIndex = 0; ErrorIndex < ErrorMessages.Num(); ++ErrorIndex)
{
FMessageLog("SourceControl").Error(ErrorMessages[ErrorIndex]);
}
}
}
return bCommandOK;
}
ELocalizationServiceOperationCommandResult::Type FOneSkyLocalizationServiceProvider::Execute(const TSharedRef<ILocalizationServiceOperation, ESPMode::ThreadSafe>& InOperation, const TArray<FLocalizationServiceTranslationIdentifier>& InTranslationIds, ELocalizationServiceOperationConcurrency::Type InConcurrency, const FLocalizationServiceOperationComplete& InOperationCompleteDelegate)
{
if(!IsEnabled())
{
return ELocalizationServiceOperationCommandResult::Failed;
}
// Query to see if the we allow this operation
TSharedPtr<IOneSkyLocalizationServiceWorker, ESPMode::ThreadSafe> Worker = CreateWorker(InOperation->GetName());
if(!Worker.IsValid())
{
// this operation is unsupported by this source control provider
FFormatNamedArguments Arguments;
Arguments.Add( TEXT("OperationName"), FText::FromName(InOperation->GetName()) );
Arguments.Add( TEXT("ProviderName"), FText::FromName(GetName()) );
FMessageLog("LocalizationService").Error(FText::Format(LOCTEXT("UnsupportedOperation", "Operation '{OperationName}' not supported by source control provider '{ProviderName}'"), Arguments));
return ELocalizationServiceOperationCommandResult::Failed;
}
// fire off operation
if(InConcurrency == ELocalizationServiceOperationConcurrency::Synchronous)
{
FOneSkyLocalizationServiceCommand* Command = new FOneSkyLocalizationServiceCommand(InOperation, Worker.ToSharedRef());
Command->bAutoDelete = false;
Command->OperationCompleteDelegate = InOperationCompleteDelegate;
return ExecuteSynchronousCommand(*Command, InOperation->GetInProgressString(), true);
}
else
{
FOneSkyLocalizationServiceCommand* Command = new FOneSkyLocalizationServiceCommand(InOperation, Worker.ToSharedRef());
Command->bAutoDelete = true;
Command->OperationCompleteDelegate = InOperationCompleteDelegate;
return IssueCommand(*Command, false);
}
}
bool UBasicVolumeComponent::SetBasicVolume(UBasicVolume* NewVolume)
{
if (NewVolume == GetVolume() && NewVolume == nullptr)
return false;
AActor* Owner = GetOwner();
if (!AreDynamicDataChangesAllowed() && Owner != NULL)
{
FMessageLog("PIE").Warning(FText::Format(
FText::FromString(TEXT("Calling SetBasicVolume on '{0}' but Mobility is Static.")),
FText::FromString(GetPathName())));
return false;
}
if (m_octree.IsValid())
{
m_octree.Reset();
}
PRAGMA_DISABLE_DEPRECATION_WARNINGS
Volume = NewVolume;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
// If there were a volume before we call then we force gc
UWorld* World = GetWorld();
if (World)
{
World->ForceGarbageCollection(true);
}
EnsureRendering();
return true;
}
TArray< TSharedRef<ISourceControlLabel> > FPerforceSourceControlProvider::GetLabels( const FString& InMatchingSpec ) const
{
TArray< TSharedRef<ISourceControlLabel> > Labels;
FPerforceSourceControlModule& PerforceSourceControl = FModuleManager::LoadModuleChecked<FPerforceSourceControlModule>("PerforceSourceControl");
FScopedPerforceConnection ScopedConnection(EConcurrency::Synchronous, PerforceSourceControl.AccessSettings().GetConnectionInfo());
if(ScopedConnection.IsValid())
{
FPerforceConnection& Connection = ScopedConnection.GetConnection();
FP4RecordSet Records;
TArray<FString> Parameters;
TArray<FText> ErrorMessages;
Parameters.Add(TEXT("-E"));
Parameters.Add(InMatchingSpec);
bool bConnectionDropped = false;
if(Connection.RunCommand(TEXT("labels"), Parameters, Records, ErrorMessages, FOnIsCancelled(), bConnectionDropped))
{
ParseGetLabelsResults(Records, Labels);
}
else
{
// output errors if any
for (int32 ErrorIndex = 0; ErrorIndex < ErrorMessages.Num(); ++ErrorIndex)
{
FMessageLog("SourceControl").Warning(ErrorMessages[ErrorIndex]);
}
}
}
return Labels;
}
bool FSubversionSourceControlRevision::GetAnnotated( TArray<FAnnotationLine>& OutLines ) const
{
SubversionSourceControlUtils::CheckFilename(Filename);
FSubversionSourceControlModule& SubversionSourceControl = FModuleManager::LoadModuleChecked<FSubversionSourceControlModule>( "SubversionSourceControl" );
FSubversionSourceControlProvider& Provider = SubversionSourceControl.GetProvider();
TArray<FString> Results;
TArray<FString> Parameters;
TArray<FString> ErrorMessages;
// Make temp filename to export to
FString RevString = (RevisionNumber < 0) ? TEXT("HEAD") : FString::Printf(TEXT("%d"), RevisionNumber);
Parameters.Add(FString(TEXT("--revision ")) + RevString);
Parameters.Add(TEXT("--use-merge-history"));
TArray<FString> Files;
Files.Add(Filename);
if(SubversionSourceControlUtils::RunCommand(TEXT("blame"), Files, Parameters, Results, ErrorMessages, Provider.GetUserName()))
{
ParseBlameResults(Results, OutLines);
return true;
}
else
{
for(auto Iter(ErrorMessages.CreateConstIterator()); Iter; Iter++)
{
FMessageLog("SourceControl").Error(FText::FromString(*Iter));
}
}
return false;
}
void AFunctionalTest::FinishTest(TEnumAsByte<EFunctionalTestResult::Type> TestResult, const FString& Message)
{
const static UEnum* FTestResultTypeEnum = FindObject<UEnum>( NULL, TEXT("FunctionalTesting.FunctionalTest.EFunctionalTestResult") );
bIsRunning = false;
SetActorTickEnabled(false);
OnTestFinished.Broadcast();
AActor** ActorToDestroy = AutoDestroyActors.GetTypedData();
for (int32 ActorIndex = 0; ActorIndex < AutoDestroyActors.Num(); ++ActorIndex, ++ActorToDestroy)
{
if (*ActorToDestroy != NULL)
{
// will be removed next frame
(*ActorToDestroy)->SetLifeSpan( 0.01f );
}
}
const FText ResultText = FTestResultTypeEnum->GetEnumText( TestResult.GetValue() );
const FString OutMessage = FString::Printf(TEXT("%s> Result: %s> %s")
, *GetActorLabel()
, *ResultText.ToString()
, Message.IsEmpty() == false ? *Message : TEXT("Test finished") );
AutoDestroyActors.Reset();
EMessageSeverity::Type MessageLogSeverity = EMessageSeverity::Info;
switch (TestResult.GetValue())
{
case EFunctionalTestResult::Invalid:
case EFunctionalTestResult::Error:
UE_VLOG(this, LogFunctionalTest, Error, TEXT("%s"), *OutMessage);
MessageLogSeverity = EMessageSeverity::Error;
break;
case EFunctionalTestResult::Running:
UE_VLOG(this, LogFunctionalTest, Warning, TEXT("%s"), *OutMessage);
MessageLogSeverity = EMessageSeverity::Warning;
break;
case EFunctionalTestResult::Failed:
UE_VLOG(this, LogFunctionalTest, Error, TEXT("%s"), *OutMessage);
MessageLogSeverity = EMessageSeverity::Error;
break;
default:
UE_VLOG(this, LogFunctionalTest, Log, TEXT("%s"), *OutMessage);
break;
}
FMessageLog("FunctionalTestingLog").Message(MessageLogSeverity, FText::FromString(GetActorLabel()))
->AddToken( FTextToken::Create( ResultText ) )
->AddToken( FTextToken::Create( Message.IsEmpty() == false ? FText::FromString(Message) : NSLOCTEXT("FunctionalTest", "FinishedTest", "Test finished") ) );
TestFinishedObserver.ExecuteIfBound(this);
}
void UPhysicsConstraintComponent::CheckForErrors()
{
Super::CheckForErrors();
UPrimitiveComponent* PrimComp1 = GetComponentInternal(EConstraintFrame::Frame1);
UPrimitiveComponent* PrimComp2 = GetComponentInternal(EConstraintFrame::Frame2);
// Check we have something to joint
if( PrimComp1 == NULL && PrimComp2 == NULL )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("OwnerName"), FText::FromString(GetNameSafe(GetOwner())));
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(FText::Format( LOCTEXT("NoComponentsFound","{OwnerName} : No components found to joint."), Arguments ) ));
}
// Make sure constraint components are not both static.
else if ( PrimComp1 != NULL && PrimComp2 != NULL )
{
if ( PrimComp1->Mobility != EComponentMobility::Movable && PrimComp2->Mobility != EComponentMobility::Movable )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("OwnerName"), FText::FromString(GetNameSafe(GetOwner())));
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(FText::Format( LOCTEXT("BothComponentsStatic","{OwnerName} : Both components are static."), Arguments ) ));
}
}
else
{
// At this point, we know one constraint component is NULL and the other is non-NULL.
// Check that the non-NULL constraint component is dynamic.
if ( ( PrimComp1 == NULL && PrimComp2->Mobility != EComponentMobility::Movable ) ||
( PrimComp2 == NULL && PrimComp1->Mobility != EComponentMobility::Movable ) )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("OwnerName"), FText::FromString(GetNameSafe(GetOwner())));
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(FText::Format( LOCTEXT("SingleStaticComponent","{OwnerName} : Connected to single static component."), Arguments ) ));
}
}
}
void AAmbientSound::CheckForErrors( void )
{
Super::CheckForErrors();
if( !AudioComponent )
{
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(LOCTEXT( "MapCheck_Message_AudioComponentNull", "Ambient sound actor has NULL AudioComponent property - please delete")))
->AddToken(FMapErrorToken::Create(FMapErrors::AudioComponentNull));
}
else if( AudioComponent->Sound == NULL )
{
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(LOCTEXT( "MapCheck_Message_SoundCueNull", "Ambient sound actor has NULL Sound Cue property")))
->AddToken(FMapErrorToken::Create(FMapErrors::SoundCueNull));
}
}
USoundWave* ImportSoundWave(const FString& InSoundWavePackageName, const FString& InSoundWaveAssetName, const FString& InWavFilename) const
{
// Find or create the package to host the sound wave
UPackage* const SoundWavePackage = CreatePackage(nullptr, *InSoundWavePackageName);
if (!SoundWavePackage)
{
FMessageLog("Import").Error(FText::Format(LOCTEXT("SoundWavePackageError", "Failed to create a sound wave package '{0}'."), FText::FromString(InSoundWavePackageName)));
return nullptr;
}
// Make sure the destination package is loaded
SoundWavePackage->FullyLoad();
// We set the correct options in the constructor, so run the import silently
USoundFactory* SoundWaveFactory = NewObject<USoundFactory>();
SoundWaveFactory->SuppressImportOverwriteDialog();
// Perform the actual import
USoundWave* const SoundWave = ImportObject<USoundWave>(SoundWavePackage, *InSoundWaveAssetName, RF_Public | RF_Standalone, *InWavFilename, nullptr, SoundWaveFactory);
if (!SoundWave)
{
FMessageLog("Import").Error(FText::Format(LOCTEXT("SoundWaveImportError", "Failed to import the sound wave asset '{0}.{1}' from '{2}'"), FText::FromString(InSoundWavePackageName), FText::FromString(InSoundWaveAssetName), FText::FromString(InWavFilename)));
return nullptr;
}
// Compress to whatever formats the active target platforms want prior to saving the asset
{
ITargetPlatformManagerModule* TPM = GetTargetPlatformManager();
if (TPM)
{
const TArray<ITargetPlatform*>& Platforms = TPM->GetActiveTargetPlatforms();
for (ITargetPlatform* Platform : Platforms)
{
SoundWave->GetCompressedData(Platform->GetWaveFormat(SoundWave));
}
}
}
FAssetRegistryModule& AssetRegistry = FModuleManager::Get().LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
AssetRegistry.AssetCreated(SoundWave);
return SoundWave;
}
void ANote::CheckForErrors()
{
Super::CheckForErrors();
if( Text.Len() > 0 )
{
FMessageLog("MapCheck").Info()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create( FText::FromString( Text ) ) );
}
}
bool UUserWidget::AddToPlayerScreen(int32 ZOrder)
{
if ( ULocalPlayer* LocalPlayer = GetOwningLocalPlayer() )
{
AddToScreen(LocalPlayer, ZOrder);
return true;
}
FMessageLog("PIE").Error(LOCTEXT("AddToPlayerScreen_NoPlayer", "AddToPlayerScreen Failed. No Owning Player!"));
return false;
}
bool AHUD::IsCanvasValid_WarnIfNot() const
{
const bool bIsValid = Canvas != NULL;
if (!bIsValid)
{
FMessageLog("PIE").Warning()
->AddToken(FUObjectToken::Create(const_cast<AHUD*>(this)))
->AddToken(FTextToken::Create(LOCTEXT( "PIE_Warning_Message_CanvasCallOutsideOfDrawCanvas", "Canvas Draw functions may only be called during the handling of the DrawHUD event" )));
}
return bIsValid;
}
void UPrimitiveComponent::WarnInvalidPhysicsOperations_Internal(const FText& ActionText, const FBodyInstance* BI) const
{
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
if (!CheckStaticMobilityAndWarn(ActionText)) //all physics operations require non-static mobility
{
if (BI)
{
ECollisionEnabled::Type CollisionEnabled = BI->GetCollisionEnabled();
if(BI->bSimulatePhysics == false) //some require to be simulating too
{
FMessageLog("PIE").Warning(FText::Format(LOCTEXT("InvalidPhysicsOperation", "{0} has to have 'Simulate Physics' enabled if you'd like to {1}. "), FText::FromString(GetReadableName()), ActionText));
}
else if (CollisionEnabled == ECollisionEnabled::NoCollision || CollisionEnabled == ECollisionEnabled::QueryOnly) //shapes need to be simulating
{
FMessageLog("PIE").Warning(FText::Format(LOCTEXT("InvalidPhysicsOperation", "{0} has to have 'CollisionEnabled' set to 'Query and Physics' or 'Physics only' if you'd like to {1}. "), FText::FromString(GetReadableName()), ActionText));
}
}
}
#endif
}
void AWorldSettings::CheckForErrors()
{
Super::CheckForErrors();
UWorld* World = GetWorld();
if ( World->GetWorldSettings() != this )
{
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(LOCTEXT( "MapCheck_Message_DuplicateLevelInfo", "Duplicate level info" ) ))
->AddToken(FMapErrorToken::Create(FMapErrors::DuplicateLevelInfo));
}
if( World->NumLightingUnbuiltObjects > 0 )
{
FMessageLog("MapCheck").Error()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(LOCTEXT( "MapCheck_Message_RebuildLighting", "Maps need lighting rebuilt" ) ))
->AddToken(FMapErrorToken::Create(FMapErrors::RebuildLighting));
}
}
void UCameraComponent::CheckForErrors()
{
Super::CheckForErrors();
if (AspectRatio <= 0.0f)
{
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(LOCTEXT( "MapCheck_Message_CameraAspectRatioIsZero", "Camera has AspectRatio=0 - please set this to something non-zero" ) ))
->AddToken(FMapErrorToken::Create(FMapErrors::CameraAspectRatioIsZero));
}
}
void UPrimitiveComponent::WarnInvalidPhysicsOperations_Internal(const FText& ActionText, const FBodyInstance* BI) const
{
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
if (!CheckStaticMobilityAndWarn(ActionText)) //all physics operations require non-static mobility
{
if (BI && BI->bSimulatePhysics == false) //some require to be simulating too
{
FMessageLog("PIE").Warning(FText::Format(LOCTEXT("InvalidPhysicsOperation", "{0} has to have 'Simulate Physics' enabled if you'd like to {1}. "), FText::FromString(GetReadableName()), ActionText));
}
}
#endif
}
void AActor::CheckForDeprecated()
{
if ( GetClass()->HasAnyClassFlags(CLASS_Deprecated) )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("ActorName"), FText::FromString(GetName()));
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(FText::Format(LOCTEXT( "MapCheck_Message_ActorIsObselete_Deprecated", "{ActorName} : Obsolete and must be removed! (Class is deprecated)" ), Arguments) ))
->AddToken(FMapErrorToken::Create(FMapErrors::ActorIsObselete));
}
if ( GetClass()->HasAnyClassFlags(CLASS_Abstract) )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("ActorName"), FText::FromString(GetName()));
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(FText::Format(LOCTEXT( "MapCheck_Message_ActorIsObselete_Abstract", "{ActorName} : Obsolete and must be removed! (Class is abstract)" ), Arguments) ) )
->AddToken(FMapErrorToken::Create(FMapErrors::ActorIsObselete));
}
}
void ALight::CheckForErrors()
{
Super::CheckForErrors();
if( !LightComponent )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("ActorName"), FText::FromString(GetName()));
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(FText::Format(LOCTEXT( "MapCheck_Message_LightComponentNull", "{ActorName} : Light actor has NULL LightComponent property - please delete!" ), Arguments) ))
->AddToken(FMapErrorToken::Create(FMapErrors::LightComponentNull));
}
}
void APainCausingVolume::CheckForErrors()
{
Super::CheckForErrors();
if ( !DamageType )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("ActorName"), FText::FromString(GetName()));
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(FText::Format(LOCTEXT( "MapCheck_Message_NoDamageType", "{ActorName} : Causes damage but has no DamageType defined" ), Arguments) ))
->AddToken(FMapErrorToken::Create(FMapErrors::NoDamageType));
}
}
void UUserWidget::AddToScreen(ULocalPlayer* Player, int32 ZOrder)
{
if ( !FullScreenWidget.IsValid() )
{
// First create and initialize the variable so that users calling this function twice don't
// attempt to add the widget to the viewport again.
TSharedRef<SConstraintCanvas> FullScreenCanvas = SNew(SConstraintCanvas);
FullScreenWidget = FullScreenCanvas;
TSharedRef<SWidget> UserSlateWidget = TakeWidget();
FullScreenCanvas->AddSlot()
.Offset(BIND_UOBJECT_ATTRIBUTE(FMargin, GetFullScreenOffset))
.Anchors(BIND_UOBJECT_ATTRIBUTE(FAnchors, GetViewportAnchors))
.Alignment(BIND_UOBJECT_ATTRIBUTE(FVector2D, GetFullScreenAlignment))
[
UserSlateWidget
];
// If this is a game world add the widget to the current worlds viewport.
UWorld* World = GetWorld();
if ( World && World->IsGameWorld() )
{
if ( UGameViewportClient* ViewportClient = World->GetGameViewport() )
{
if ( Player )
{
ViewportClient->AddViewportWidgetForPlayer(Player, FullScreenCanvas, ZOrder);
}
else
{
// We add 10 to the zorder when adding to the viewport to avoid
// displaying below any built-in controls, like the virtual joysticks on mobile builds.
ViewportClient->AddViewportWidgetContent(FullScreenCanvas, ZOrder + 10);
}
// Just in case we already hooked this delegate, remove the handler.
FWorldDelegates::LevelRemovedFromWorld.RemoveAll(this);
// Widgets added to the viewport are automatically removed if the persistent level is unloaded.
FWorldDelegates::LevelRemovedFromWorld.AddUObject(this, &UUserWidget::OnLevelRemovedFromWorld);
}
}
}
else
{
FMessageLog("PIE").Warning(FText::Format(LOCTEXT("WidgetAlreadyOnScreen", "The widget '{0}' was already added to the screen."),
FText::FromString(GetClass()->GetName())));
}
}
float UUserInterfaceSettings::GetDPIScaleBasedOnSize(FIntPoint Size) const
{
float Scale = 1;
if ( UIScaleRule == EUIScalingRule::Custom )
{
if ( CustomScalingRuleClassInstance == nullptr )
{
CustomScalingRuleClassInstance = CustomScalingRuleClass.TryLoadClass<UDPICustomScalingRule>();
if ( CustomScalingRuleClassInstance == nullptr )
{
FMessageLog("MapCheck").Error()
->AddToken(FTextToken::Create(FText::Format(LOCTEXT("CustomScalingRule_NotFound", "Project Settings - User Interface Custom Scaling Rule '{0}' could not be found."), FText::FromString(CustomScalingRuleClass.ToString()))));
return 1;
}
}
if ( CustomScalingRule == nullptr )
{
CustomScalingRule = CustomScalingRuleClassInstance->GetDefaultObject<UDPICustomScalingRule>();
}
Scale = CustomScalingRule->GetDPIScaleBasedOnSize(Size);
}
else
{
int32 EvalPoint = 0;
switch ( UIScaleRule )
{
case EUIScalingRule::ShortestSide:
EvalPoint = FMath::Min(Size.X, Size.Y);
break;
case EUIScalingRule::LongestSide:
EvalPoint = FMath::Max(Size.X, Size.Y);
break;
case EUIScalingRule::Horizontal:
EvalPoint = Size.X;
break;
case EUIScalingRule::Vertical:
EvalPoint = Size.Y;
break;
}
const FRichCurve* DPICurve = UIScaleCurve.GetRichCurveConst();
Scale = DPICurve->Eval((float)EvalPoint, 1.0f);
}
return FMath::Max(Scale * ApplicationScale, 0.01f);
}
bool UK2Node_Variable::RemapRestrictedLinkReference(FName OldVariableName, FName NewVariableName, const UClass* MatchInVariableClass, const UClass* RemapIfLinkedToClass, bool bLogWarning)
{
bool bRemapped = false;
if (VariableReference.GetMemberName() == OldVariableName)
{
UClass* const VarClass = GetVariableSourceClass();
if (VarClass->IsChildOf(MatchInVariableClass))
{
UEdGraphPin* VariablePin = GetValuePin();
if (VariablePin)
{
for (UEdGraphPin* OtherPin : VariablePin->LinkedTo)
{
if (OtherPin != nullptr && VariablePin->PinType.PinCategory == OtherPin->PinType.PinCategory)
{
// If any other pin we are linked to is a more restricted type, we need to do the remap.
const UClass* OtherPinClass = Cast<UClass>(OtherPin->PinType.PinSubCategoryObject.Get());
if (OtherPinClass && OtherPinClass->IsChildOf(RemapIfLinkedToClass))
{
if (VariableReference.IsSelfContext())
{
VariableReference.SetSelfMember(NewVariableName);
}
else
{
VariableReference.SetExternalMember(NewVariableName, VarClass);
}
bRemapped = true;
break;
}
}
}
}
}
}
if (bRemapped && bLogWarning && GetBlueprint())
{
FMessageLog("BlueprintLog").Warning(
FText::Format(
LOCTEXT("RemapRestrictedLinkReference", "{0}: Variable '{1}' was automatically changed to '{2}'. Verify that logic works as intended. (This warning will disappear once the blueprint has been resaved)"),
FText::FromString(GetBlueprint()->GetPathName()),
FText::FromString(MatchInVariableClass->GetName() + TEXT(".") + OldVariableName.ToString()),
FText::FromString(MatchInVariableClass->GetName() + TEXT(".") + NewVariableName.ToString())
));
}
return bRemapped;
}
bool FSubversionSourceControlRevision::Get( FString& InOutFilename ) const
{
SubversionSourceControlUtils::CheckFilename(Filename);
FSubversionSourceControlModule& SubversionSourceControl = FModuleManager::LoadModuleChecked<FSubversionSourceControlModule>( "SubversionSourceControl" );
FSubversionSourceControlProvider& Provider = SubversionSourceControl.GetProvider();
TArray<FString> Results;
TArray<FString> Parameters;
TArray<FString> ErrorMessages;
// Make temp filename to export to
FString RevString = (RevisionNumber < 0) ? TEXT("HEAD") : FString::Printf(TEXT("%d"), RevisionNumber);
FString AbsoluteFileName;
if(InOutFilename.Len() > 0)
{
AbsoluteFileName = InOutFilename;
}
else
{
// create the diff dir if we don't already have it (SVN wont)
IFileManager::Get().MakeDirectory(*FPaths::DiffDir(), true);
static int32 TempFileCount = 0;
FString TempFileName = FString::Printf(TEXT("%sTemp-%d-Rev-%s-%s"), *FPaths::DiffDir(), TempFileCount++, *RevString, *FPaths::GetCleanFilename(Filename));
AbsoluteFileName = FPaths::ConvertRelativePathToFull(TempFileName);
}
Parameters.Add(FString(TEXT("--revision ")) + RevString);
Parameters.Add(TEXT("--force"));
TArray<FString> Files;
Files.Add(Filename);
Files.Add(AbsoluteFileName);
if(SubversionSourceControlUtils::RunCommand(TEXT("export"), Files, Parameters, Results, ErrorMessages, Provider.GetUserName()))
{
InOutFilename = AbsoluteFileName;
return true;
}
else
{
for(auto Iter(ErrorMessages.CreateConstIterator()); Iter; Iter++)
{
FMessageLog("SourceControl").Error(FText::FromString(*Iter));
}
}
return false;
}
void ALevelStreamingVolume::CheckForErrors()
{
Super::CheckForErrors();
// Streaming level volumes are not permitted outside the persistent level.
if ( GetLevel() != GetWorld()->PersistentLevel )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("ActorName"), FText::FromString(GetName()));
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(FText::Format(LOCTEXT( "MapCheck_Message_LevelStreamingVolume", "{ActorName} : LevelStreamingVolume is not in the persistent level - please delete" ), Arguments) ))
->AddToken(FMapErrorToken::Create(FMapErrors::LevelStreamingVolume));
}
// Warn if the volume has no streaming levels associated with it
bool bHasAssociatedLevels = false;
for (auto It = GetWorld()->StreamingLevels.CreateConstIterator(); It; ++It)
{
if ((*It)->EditorStreamingVolumes.Find(this) != INDEX_NONE)
{
bHasAssociatedLevels = true;
break;
}
}
if ( !bHasAssociatedLevels )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("ActorName"), FText::FromString(GetName()));
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(FText::Format(LOCTEXT( "MapCheck_Message_NoLevelsAssociatedWithStreamingVolume", "{ActorName} : No levels are associated with streaming volume." ), Arguments) ))
->AddToken(FMapErrorToken::Create(FMapErrors::NoLevelsAssociated));
}
}
void UAnimInstance::RegisterSlotNode(FName SlotNodeName)
{
// verify if same slot node name exists
// then warn users, this is invalid
for (auto Iter = ActiveSlotWeights.CreateConstIterator(); Iter; ++Iter)
{
// if same name found, we should warn user, and make sure they know about it
if ( SlotNodeName == Iter.Key() )
{
FMessageLog("AnimBlueprint").Warning(FText::Format(LOCTEXT("AnimInstance_SlotNode", "SLOTNODE: '{0}' already exists. Each slot node has to have unique name."), FText::FromString(SlotNodeName.ToString())));
return;
}
}
ActiveSlotWeights.Add(SlotNodeName, 0.f);
}
void AEmitter::CheckForErrors()
{
Super::CheckForErrors();
// Emitters placed in a level should have a non-NULL ParticleSystemComponent.
UObject* Outer = GetOuter();
if (Cast<ULevel>(Outer))
{
if (!ParticleSystemComponent)
{
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(LOCTEXT("MapCheck_Message_ParticleSystemComponentNull", "Emitter actor has NULL ParticleSystemComponent property - please delete")))
->AddToken(FMapErrorToken::Create(FMapErrors::ParticleSystemComponentNull));
}
}
}