void FCombinedGraphDataSource::GetStartIndicesFromTimeRange( const float StartTimeMS, const float EndTimeMS, TMap<FGuid,uint32>& out_StartIndices ) const
{
for( auto It = GetSourcesIterator(); It; ++It )
{
const FGraphDataSourceRefConst& GraphDataSource = It.Value();
const FIntPoint IndicesForFrame = GraphDataSource->GetDataProvider()->GetClosestSamplesIndicesForTime( StartTimeMS, EndTimeMS );
const uint32 StartFrameIndex = IndicesForFrame.X;
const uint32 EndFrameIndex = IndicesForFrame.Y;
uint32 FrameIndex = 0;
float MaxFrameTime = 0.0f;
// Iterate through all frames and find the highest frame time.
for( uint32 InnerFrameIndex = StartFrameIndex; InnerFrameIndex < EndFrameIndex; ++InnerFrameIndex )
{
const float InnerFrameTime = GraphDataSource->GetDataProvider()->GetFrameTimeMS( InnerFrameIndex );
if( InnerFrameTime > MaxFrameTime )
{
MaxFrameTime = InnerFrameTime;
FrameIndex = InnerFrameIndex;
}
}
if( MaxFrameTime > 0.0f )
{
out_StartIndices.Add( GraphDataSource->GetSessionInstanceID(), FrameIndex );
}
}
}
void SWidget::FindChildGeometries_Helper( const FGeometry& MyGeometry, const TSet< TSharedRef<SWidget> >& WidgetsToFind, TMap<TSharedRef<SWidget>, FArrangedWidget>& OutResult ) const
{
// Perform a breadth first search!
FArrangedChildren ArrangedChildren(EVisibility::Visible);
this->ArrangeChildren( MyGeometry, ArrangedChildren );
const int32 NumChildren = ArrangedChildren.Num();
// See if we found any of the widgets on this level.
for(int32 ChildIndex=0; ChildIndex < NumChildren; ++ChildIndex )
{
const FArrangedWidget& CurChild = ArrangedChildren[ ChildIndex ];
if ( WidgetsToFind.Contains(CurChild.Widget) )
{
// We found one of the widgets for which we need geometry!
OutResult.Add( CurChild.Widget, CurChild );
}
}
// If we have not found all the widgets that we were looking for, descend.
if ( OutResult.Num() != WidgetsToFind.Num() )
{
// Look for widgets among the children.
for( int32 ChildIndex=0; ChildIndex < NumChildren; ++ChildIndex )
{
const FArrangedWidget& CurChild = ArrangedChildren[ ChildIndex ];
CurChild.Widget->FindChildGeometries_Helper( CurChild.Geometry, WidgetsToFind, OutResult );
}
}
}
/** Recursively generates a histogram of nodes and stores their timing in TimingResult. */
static void GatherStatsEventNode(FGPUProfilerEventNode* Node, int32 Depth, TMap<FString, FGPUProfilerEventNodeStats>& EventHistogram)
{
if (Node->NumDraws > 0 || Node->Children.Num() > 0)
{
Node->TimingResult = Node->GetTiming() * 1000.0f;
FGPUProfilerEventNodeStats* FoundHistogramBucket = EventHistogram.Find(Node->Name);
if (FoundHistogramBucket)
{
FoundHistogramBucket->NumDraws += Node->NumDraws;
FoundHistogramBucket->NumPrimitives += Node->NumPrimitives;
FoundHistogramBucket->NumVertices += Node->NumVertices;
FoundHistogramBucket->TimingResult += Node->TimingResult;
FoundHistogramBucket->NumEvents++;
}
else
{
FGPUProfilerEventNodeStats NewNodeStats;
NewNodeStats.NumDraws = Node->NumDraws;
NewNodeStats.NumPrimitives = Node->NumPrimitives;
NewNodeStats.NumVertices = Node->NumVertices;
NewNodeStats.TimingResult = Node->TimingResult;
NewNodeStats.NumEvents = 1;
EventHistogram.Add(Node->Name, NewNodeStats);
}
for (int32 ChildIndex = 0; ChildIndex < Node->Children.Num(); ChildIndex++)
{
// Traverse children
GatherStatsEventNode(Node->Children[ChildIndex], Depth + 1, EventHistogram);
}
}
}
void AddStateWeight(TMap<int32, float>& StateWeightMap, int32 StateIndex, float Weight)
{
if (!StateWeightMap.Find(StateIndex))
{
StateWeightMap.Add(StateIndex) = Weight;
}
}
void FBaseParser::InsertMetaDataPair(TMap<FName, FString>& MetaData, const FString& InKey, const FString& InValue)
{
FString Key = InKey;
FString Value = InValue;
// trim extra white space and quotes
Key = Key.Trim().TrimTrailing();
Value = Value.Trim().TrimTrailing();
Value = Value.TrimQuotes();
// make sure the key is valid
if (InKey.Len() == 0)
{
FError::Throwf(TEXT("Invalid metadata"));
}
FName KeyName(*Key);
FString* ExistingValue = MetaData.Find(KeyName);
if (ExistingValue && Value != *ExistingValue)
{
FError::Throwf(TEXT("Metadata key '%s' first seen with value '%s' then '%s'"), *Key, **ExistingValue, *Value);
}
// finally we have enough to put it into our metadata
MetaData.Add(FName(*Key), *Value);
}
void Bind(UJavascriptDelegate* DelegateObject, Local<Function> function)
{
static FName NAME_Fire("Fire");
if (WeakObject.IsValid())
{
if (auto p = Cast<UMulticastDelegateProperty>(Property))
{
FScriptDelegate Delegate;
Delegate.BindUFunction(DelegateObject, NAME_Fire);
auto Target = p->GetPropertyValuePtr_InContainer(WeakObject.Get());
Target->Add(Delegate);
}
else if (auto p = Cast<UDelegateProperty>(Property))
{
auto Target = p->GetPropertyValuePtr_InContainer(WeakObject.Get());
Target->BindUFunction(DelegateObject, NAME_Fire);
}
}
DelegateObject->JavascriptDelegate = this;
DelegateObject->AddToRoot();
DelegateObjects.Add(DelegateObject);
functions.Add( DelegateObject->UniqueId, UniquePersistent<Function>(isolate_, function) );
}
AGameplayDebuggerPlayerManager& FGameplayDebuggerModule::GetPlayerManager(UWorld* World)
{
const int32 PurgeInvalidWorldsSize = 5;
if (PlayerManagers.Num() > PurgeInvalidWorldsSize)
{
for (TMap<TWeakObjectPtr<UWorld>, TWeakObjectPtr<AGameplayDebuggerPlayerManager> >::TIterator It(PlayerManagers); It; ++It)
{
if (!It.Key().IsValid())
{
It.RemoveCurrent();
}
else if (!It.Value().IsValid())
{
It.RemoveCurrent();
}
}
}
TWeakObjectPtr<AGameplayDebuggerPlayerManager> Manager = PlayerManagers.FindRef(World);
AGameplayDebuggerPlayerManager* ManagerOb = Manager.Get();
if (ManagerOb == nullptr)
{
ManagerOb = World->SpawnActor<AGameplayDebuggerPlayerManager>();
PlayerManagers.Add(World, ManagerOb);
}
check(ManagerOb);
return *ManagerOb;
}
FVertexDeclarationRHIRef FOpenGLDynamicRHI::RHICreateVertexDeclaration(const FVertexDeclarationElementList& Elements)
{
// Construct a key from the elements.
FOpenGLVertexDeclarationKey Key(Elements);
// Check for a cached vertex declaration.
FVertexDeclarationRHIRef* VertexDeclarationRefPtr = GOpenGLVertexDeclarationCache.Find(Key);
if (VertexDeclarationRefPtr == NULL)
{
// Create and add to the cache if it doesn't exist.
VertexDeclarationRefPtr = &GOpenGLVertexDeclarationCache.Add(Key,new FOpenGLVertexDeclaration(Key.VertexElements));
check(VertexDeclarationRefPtr);
check(IsValidRef(*VertexDeclarationRefPtr));
FShaderCache::LogVertexDeclaration(Elements, *VertexDeclarationRefPtr);
}
// The cached declaration must match the input declaration!
check(VertexDeclarationRefPtr);
check(IsValidRef(*VertexDeclarationRefPtr));
FOpenGLVertexDeclaration* OpenGLVertexDeclaration = (FOpenGLVertexDeclaration*)VertexDeclarationRefPtr->GetReference();
checkSlow(OpenGLVertexDeclaration->VertexElements == Key.VertexElements);
return *VertexDeclarationRefPtr;
}
void FModuleDescriptor::LoadModulesForPhase(ELoadingPhase::Type LoadingPhase, const TArray<FModuleDescriptor>& Modules, TMap<FName, EModuleLoadResult>& ModuleLoadErrors)
{
for(int Idx = 0; Idx < Modules.Num(); Idx++)
{
const FModuleDescriptor& Descriptor = Modules[Idx];
// Don't need to do anything if this module is already loaded
if( !FModuleManager::Get().IsModuleLoaded( Descriptor.Name ) )
{
if( LoadingPhase == Descriptor.LoadingPhase && Descriptor.IsLoadedInCurrentConfiguration() )
{
// @todo plugin: DLL search problems. Plugins that statically depend on other modules within this plugin may not be found? Need to test this.
// NOTE: Loading this module may cause other modules to become loaded, both in the engine or game, or other modules
// that are part of this project or plugin. That's totally fine.
EModuleLoadResult FailureReason;
const TSharedPtr<IModuleInterface>& ModuleInterface = FModuleManager::Get().LoadModuleWithFailureReason( Descriptor.Name, FailureReason );
if( ModuleInterface.IsValid() )
{
// Module loaded OK (or was already loaded.)
}
else
{
// The module failed to load. Note this in the ModuleLoadErrors list.
ModuleLoadErrors.Add(Descriptor.Name, FailureReason);
}
}
}
}
}
void UFaceFXMatineeControl::GetTrackKeyForTime(float InTime, TArray<TPair<int32, const FFaceFXTrackKey*>>& OutResult, TArray<FFaceFXSkelMeshComponentId>* OutNoTracks) const
{
//build a list of all keys for all skelmesh component ids
TMap<int32, TArray<const FFaceFXTrackKey*>> SkelMeshTracks;
TMap<int32, FFaceFXSkelMeshComponentId> SkelMeshIds;
for(const FFaceFXTrackKey& Key : Keys)
{
SkelMeshTracks.FindOrAdd(Key.SkelMeshComponentId.Index).Add(&Key);
if(OutNoTracks && !SkelMeshIds.Contains(Key.SkelMeshComponentId.Index))
{
SkelMeshIds.Add(Key.SkelMeshComponentId.Index, Key.SkelMeshComponentId);
}
}
//then generate the pair results for each skelmesh component
for(auto It = SkelMeshTracks.CreateConstIterator(); It; ++It)
{
const TArray<const FFaceFXTrackKey*>& SkelMeshKeys = It.Value();
const int32 IndexMax = SkelMeshKeys.Num()-1;
int32 Index = INDEX_NONE;
for(; Index < IndexMax && SkelMeshKeys[Index+1]->Time <= InTime; ++Index);
if(Index != INDEX_NONE)
{
OutResult.Add(TPairInitializer<int32, const FFaceFXTrackKey*>(Index, SkelMeshKeys[Index]));
}
else if(OutNoTracks)
{
OutNoTracks->Add(SkelMeshIds.FindChecked(It.Key()));
}
}
}
void FCameraLensSettingsCustomization::CustomizeChildren(TSharedRef<IPropertyHandle> StructPropertyHandle, class IDetailChildrenBuilder& ChildBuilder, IPropertyTypeCustomizationUtils& StructCustomizationUtils)
{
// Retrieve structure's child properties
uint32 NumChildren;
StructPropertyHandle->GetNumChildren(NumChildren);
TMap<FName, TSharedPtr< IPropertyHandle > > PropertyHandles;
for (uint32 ChildIndex = 0; ChildIndex < NumChildren; ++ChildIndex)
{
TSharedRef<IPropertyHandle> ChildHandle = StructPropertyHandle->GetChildHandle(ChildIndex).ToSharedRef();
const FName PropertyName = ChildHandle->GetProperty()->GetFName();
PropertyHandles.Add(PropertyName, ChildHandle);
}
// Retrieve special case properties
MinFocalLengthHandle = PropertyHandles.FindChecked(GET_MEMBER_NAME_CHECKED(FCameraLensSettings, MinFocalLength));
MaxFocalLengthHandle = PropertyHandles.FindChecked(GET_MEMBER_NAME_CHECKED(FCameraLensSettings, MaxFocalLength));
MinFStopHandle = PropertyHandles.FindChecked(GET_MEMBER_NAME_CHECKED(FCameraLensSettings, MinFStop));
MaxFStopHandle = PropertyHandles.FindChecked(GET_MEMBER_NAME_CHECKED(FCameraLensSettings, MaxFStop));
MinFocusDistanceHandle = PropertyHandles.FindChecked(GET_MEMBER_NAME_CHECKED(FCameraLensSettings, MinimumFocusDistance));
for (auto Iter(PropertyHandles.CreateConstIterator()); Iter; ++Iter)
{
if (Iter.Value() == MinFocusDistanceHandle)
{
// skip showing these in the panel for now, as we don't really use them
continue;
}
IDetailPropertyRow& SettingsRow = ChildBuilder.AddChildProperty(Iter.Value().ToSharedRef());
}
}
void FContentComparisonHelper::RecursiveObjectCollection(UObject* InStartObject, int32 InCurrDepth, int32 InMaxDepth, TMap<UObject*,bool>& OutCollectedReferences)
{
// Serialize object with reference collector.
TArray<UObject*> LocalCollectedReferences;
FReferenceFinder ObjectReferenceCollector( LocalCollectedReferences, NULL, false, true, true, true );
ObjectReferenceCollector.FindReferences( InStartObject );
if (InCurrDepth < InMaxDepth)
{
InCurrDepth++;
for (int32 ObjRefIdx = 0; ObjRefIdx < LocalCollectedReferences.Num(); ObjRefIdx++)
{
UObject* InnerObject = LocalCollectedReferences[ObjRefIdx];
if ((InnerObject != NULL) &&
(InnerObject->IsA(UFunction::StaticClass()) == false) &&
(InnerObject->IsA(UPackage::StaticClass()) == false)
)
{
OutCollectedReferences.Add(InnerObject, true);
RecursiveObjectCollection(InnerObject, InCurrDepth, InMaxDepth, OutCollectedReferences);
}
}
InCurrDepth--;
}
}
TSharedRef< ISlateRun > FHyperlinkDecorator::Create( const FTextRunParseResults& RunInfo, const FString& OriginalText, const TSharedRef< FString >& InOutModelText, const ISlateStyle* Style )
{
FString StyleName = TEXT("Hyperlink");
const FTextRange* const MetaDataStyleNameRange = RunInfo.MetaData.Find( TEXT("style") );
if ( MetaDataStyleNameRange != NULL )
{
const FString MetaDataStyleName = OriginalText.Mid(MetaDataStyleNameRange->BeginIndex, MetaDataStyleNameRange->EndIndex - MetaDataStyleNameRange->BeginIndex);
StyleName = *MetaDataStyleName;
}
FTextRange ModelRange;
ModelRange.BeginIndex = InOutModelText->Len();
*InOutModelText += OriginalText.Mid(RunInfo.ContentRange.BeginIndex, RunInfo.ContentRange.EndIndex - RunInfo.ContentRange.BeginIndex);
ModelRange.EndIndex = InOutModelText->Len();
if ( !Style->HasWidgetStyle<FHyperlinkStyle>( FName( *StyleName ) ) )
{
Style = &FCoreStyle::Get();
}
TMap<FString, FString> MetaData;
for(const TPair<FString, FTextRange>& Pair : RunInfo.MetaData)
{
MetaData.Add(Pair.Key, OriginalText.Mid( Pair.Value.BeginIndex, Pair.Value.EndIndex - Pair.Value.BeginIndex));
//MetaData[Pair.Key] = OriginalText.Mid( Pair.Value.BeginIndex, Pair.Value.EndIndex - Pair.Value.BeginIndex);
}
return FSlateHyperlinkRun::Create( InOutModelText, Style->GetWidgetStyle<FHyperlinkStyle>( FName( *StyleName ) ), MetaData, NavigateDelegate, ModelRange );
}
TSharedRef<FUnrealTypeDefinitionInfo> AddTypeDefinition(FUnrealSourceFile& SourceFile, UField* Field, int32 Line)
{
TSharedRef<FUnrealTypeDefinitionInfo> DefinitionInfo = MakeShareable(new FUnrealTypeDefinitionInfo(SourceFile, Line));
GTypeDefinitionInfoMap.Add(Field, DefinitionInfo);
return DefinitionInfo;
}
void FDesktopPlatformWindows::EnumerateEngineInstallations(TMap<FString, FString> &OutInstallations)
{
// Enumerate the binary installations
EnumerateLauncherEngineInstallations(OutInstallations);
// Enumerate the per-user installations
HKEY hKey;
if (RegOpenKeyEx(HKEY_CURRENT_USER, InstallationsSubKey, 0, KEY_ALL_ACCESS, &hKey) == ERROR_SUCCESS)
{
// Get a list of all the directories
TArray<FString> UniqueDirectories;
OutInstallations.GenerateValueArray(UniqueDirectories);
// Enumerate all the installations
TArray<FString> InvalidKeys;
for (::DWORD Index = 0;; Index++)
{
TCHAR ValueName[256];
TCHAR ValueData[MAX_PATH];
::DWORD ValueType = 0;
::DWORD ValueNameLength = sizeof(ValueName) / sizeof(ValueName[0]);
::DWORD ValueDataSize = sizeof(ValueData);
LRESULT Result = RegEnumValue(hKey, Index, ValueName, &ValueNameLength, NULL, &ValueType, (BYTE*)&ValueData[0], &ValueDataSize);
if(Result == ERROR_SUCCESS)
{
int32 ValueDataLength = ValueDataSize / sizeof(TCHAR);
if(ValueDataLength > 0 && ValueData[ValueDataLength - 1] == 0) ValueDataLength--;
FString NormalizedInstalledDirectory(ValueDataLength, ValueData);
FPaths::NormalizeDirectoryName(NormalizedInstalledDirectory);
FPaths::CollapseRelativeDirectories(NormalizedInstalledDirectory);
if(IsValidRootDirectory(NormalizedInstalledDirectory) && !UniqueDirectories.Contains(NormalizedInstalledDirectory))
{
OutInstallations.Add(ValueName, NormalizedInstalledDirectory);
UniqueDirectories.Add(NormalizedInstalledDirectory);
}
else
{
InvalidKeys.Add(ValueName);
}
}
else if(Result == ERROR_NO_MORE_ITEMS)
{
break;
}
}
// Remove all the keys which weren't valid
for(const FString InvalidKey: InvalidKeys)
{
RegDeleteValue(hKey, *InvalidKey);
}
RegCloseKey(hKey);
}
}
void FCascadeEdPreviewViewportClient::UpdateMemoryInformation()
{
UParticleSystem* ParticleSystem = CascadePtr.Pin()->GetParticleSystem();
UCascadeParticleSystemComponent* ParticleSystemComponent = CascadePtr.Pin()->GetParticleSystemComponent();
if (ParticleSystem != NULL)
{
FArchiveCountMem MemCount(ParticleSystem);
ParticleSystemRootSize = MemCount.GetMax();
ParticleModuleMemSize = 0;
TMap<UParticleModule*,bool> ModuleList;
for (int32 EmitterIdx = 0; EmitterIdx < ParticleSystem->Emitters.Num(); EmitterIdx++)
{
UParticleEmitter* Emitter = ParticleSystem->Emitters[EmitterIdx];
if (Emitter != NULL)
{
for (int32 LODIdx = 0; LODIdx < Emitter->LODLevels.Num(); LODIdx++)
{
UParticleLODLevel* LODLevel = Emitter->LODLevels[LODIdx];
if (LODLevel != NULL)
{
ModuleList.Add(LODLevel->RequiredModule, true);
ModuleList.Add(LODLevel->SpawnModule, true);
for (int32 ModuleIdx = 0; ModuleIdx < LODLevel->Modules.Num(); ModuleIdx++)
{
ModuleList.Add(LODLevel->Modules[ModuleIdx], true);
}
}
}
}
}
for (TMap<UParticleModule*,bool>::TIterator ModuleIt(ModuleList); ModuleIt; ++ModuleIt)
{
UParticleModule* Module = ModuleIt.Key();
FArchiveCountMem ModuleCount(Module);
ParticleModuleMemSize += ModuleCount.GetMax();
}
}
if (ParticleSystemComponent != NULL)
{
FArchiveCountMem ComponentMemCount(ParticleSystemComponent);
PSysCompRootSize = ComponentMemCount.GetMax();
PSysCompResourceSize = ParticleSystemComponent->GetResourceSize(EResourceSizeMode::Exclusive);
}
}
void FBlueprintNativeCodeGenModule::InitializeForRerunDebugOnly(const TArray< TPair< FString, FString > >& CodegenTargets)
{
ReadConfig();
IBlueprintNativeCodeGenCore::Register(this);
FillTargetedForReplacementQuery();
FillIsFunctionUsedInADelegate();
for (const auto& Platform : CodegenTargets)
{
// load the old manifest:
const TCHAR* TargetDirectory = *Platform.Value;
FString OutputPath = FPaths::Combine(TargetDirectory, NativizationCookControllerImpl::DefaultPluginName, *FBlueprintNativeCodeGenPaths::GetDefaultManifestPath());
Manifests.Add(FString(*Platform.Key), TUniquePtr<FBlueprintNativeCodeGenManifest>(new FBlueprintNativeCodeGenManifest(FPaths::ConvertRelativePathToFull(OutputPath))));
//FBlueprintNativeCodeGenManifest OldManifest(FPaths::ConvertRelativePathToFull(OutputPath));
// reconvert every assets listed in the manifest:
for (const auto& ConversionTarget : GetManifest(*Platform.Key).GetConversionRecord())
{
// load the package:
UPackage* Package = LoadPackage(nullptr, *ConversionTarget.Value.TargetObjPath, LOAD_None);
if (!Package)
{
UE_LOG(LogBlueprintCodeGen, Error, TEXT("Unable to load the package: %s"), *ConversionTarget.Value.TargetObjPath);
continue;
}
// reconvert it
Convert(Package, ESavePackageResult::ReplaceCompletely, *Platform.Key);
}
// reconvert every unconverted dependency listed in the manifest:
for (const auto& ConversionTarget : GetManifest(*Platform.Key).GetUnconvertedDependencies())
{
// load the package:
UPackage* Package = LoadPackage(nullptr, *ConversionTarget.Key.GetPlainNameString(), LOAD_None);
UStruct* Struct = nullptr;
UEnum* Enum = nullptr;
GetFieldFormPackage(Package, Struct, Enum);
UBlueprint* BP = Cast<UBlueprint>(CastChecked<UClass>(Struct)->ClassGeneratedBy);
if (ensure(BP))
{
CollectBoundFunctions(BP);
GenerateSingleStub(BP, *Platform.Key);
}
}
for (TAssetPtr<UBlueprint>& BPPtr : ToGenerate)
{
UBlueprint* BP = BPPtr.LoadSynchronous();
if (ensure(BP))
{
GenerateSingleAsset(BP->GeneratedClass, *Platform.Key);
}
}
}
}
void FHardwareInfo::RegisterHardwareInfo( const FName SpecIdentifier, const FString& HardwareInfo )
{
// Ensure we are adding a valid identifier to the map
check( SpecIdentifier == NAME_RHI ||
SpecIdentifier == NAME_TextureFormat ||
SpecIdentifier == NAME_DeviceType );
HardwareDetailsMap.Add( SpecIdentifier, HardwareInfo );
}
virtual void ProcessConstructedObject(UObject* NewObject) override
{
check(NewObject);
// Add it to the new object map
NewObjectMap.Add(NewObject->GetFName(), Cast<UActorComponent>(NewObject));
// If this is a scene component and it has a parent
USceneComponent* SceneComponent = Cast<USceneComponent>(NewObject);
if (SceneComponent && SceneComponent->AttachParent)
{
// Add an entry to the child->parent name map
ParentMap.Add(NewObject->GetFName(), SceneComponent->AttachParent->GetFName());
// Clear this so it isn't used when constructing the new SCS node
SceneComponent->AttachParent = NULL;
}
}
/**
* Returns true if the specified level is locked for edit, false otherwise.
*
* @param Level The level to query.
* @return true if the level is locked, false otherwise.
*/
bool FLevelUtils::IsLevelLocked(ULevel* Level)
{
//We should not check file status on disk if we are not running the editor
#if WITH_EDITOR
// Don't permit spawning in read only levels if they are locked
if ( GIsEditor && !GIsEditorLoadingPackage )
{
if ( GEngine && GEngine->bLockReadOnlyLevels )
{
if (!LevelReadOnlyCache.Contains(Level))
{
LevelReadOnlyCache.Add(Level, FLevelReadOnlyData());
}
check(LevelReadOnlyCache.Contains(Level));
FLevelReadOnlyData &LevelData = LevelReadOnlyCache[Level];
//Make sure we test if the level file on disk is readonly only once a frame,
//when the frame time get updated.
if (LevelData.LastUpdateTime < Level->OwningWorld->GetRealTimeSeconds())
{
LevelData.LastUpdateTime = Level->OwningWorld->GetRealTimeSeconds();
//If we dont find package we dont consider it as readonly
LevelData.IsReadOnly = false;
const UPackage* pPackage = Cast<UPackage>(Level->GetOutermost());
if (pPackage)
{
FString PackageFileName;
if (FPackageName::DoesPackageExist(pPackage->GetName(), NULL, &PackageFileName))
{
LevelData.IsReadOnly = IFileManager::Get().IsReadOnly(*PackageFileName);
}
}
}
if (LevelData.IsReadOnly)
{
return true;
}
}
}
#endif //#if WITH_EDITOR
// PIE levels, the persistent level, and transient move levels are usually never locked.
if ( Level->RootPackageHasAnyFlags(PKG_PlayInEditor) || Level->IsPersistentLevel() || Level->GetName() == TEXT("TransLevelMoveBuffer") )
{
return false;
}
ULevelStreaming* StreamingLevel = FindStreamingLevel( Level );
if ( StreamingLevel != NULL )
{
return StreamingLevel->bLocked;
}
else
{
return Level->bLocked;
}
}
/** Simple parsing of a record set to update state */
static void ParseRecordSetForState(const FP4RecordSet& InRecords, TMap<FString, EPerforceState::Type>& OutResults)
{
// Iterate over each record found as a result of the command, parsing it for relevant information
for (int32 Index = 0; Index < InRecords.Num(); ++Index)
{
const FP4Record& ClientRecord = InRecords[Index];
FString FileName = ClientRecord(TEXT("clientFile"));
FString Action = ClientRecord(TEXT("action"));
check(FileName.Len());
FString FullPath(FileName);
FPaths::NormalizeFilename(FullPath);
if(Action.Len() > 0)
{
if(Action == TEXT("add"))
{
OutResults.Add(FullPath, EPerforceState::OpenForAdd);
}
else if(Action == TEXT("edit"))
{
OutResults.Add(FullPath, EPerforceState::CheckedOut);
}
else if(Action == TEXT("delete"))
{
OutResults.Add(FullPath, EPerforceState::MarkedForDelete);
}
else if(Action == TEXT("abandoned"))
{
OutResults.Add(FullPath, EPerforceState::NotInDepot);
}
else if(Action == TEXT("reverted"))
{
FString OldAction = ClientRecord(TEXT("oldAction"));
if(OldAction == TEXT("add"))
{
OutResults.Add(FullPath, EPerforceState::NotInDepot);
}
else if(OldAction == TEXT("edit"))
{
OutResults.Add(FullPath, EPerforceState::ReadOnly);
}
else if(OldAction == TEXT("delete"))
{
OutResults.Add(FullPath, EPerforceState::ReadOnly);
}
}
else if(Action == TEXT("branch"))
{
OutResults.Add(FullPath, EPerforceState::Branched);
}
}
}
}
// respond to requests from a companion app
static void WebServerDelegate(int32 UserIndex, const FString& Action, const FString& URL, const TMap<FString, FString>& Params, TMap<FString, FString>& Response)
{
if (URL == TEXT("/index.html?scoreboard"))
{
FString ScoreboardStr = TEXT("{ \"scoreboard\" : [ ");
// you shouldn't normally use this method to get a UWorld as it won't always be correct in a PIE context.
// However, the PS4 companion app server will never run in the Editor.
UGameEngine* GameEngine = CastChecked<UGameEngine>(GEngine);
if (GameEngine)
{
UWorld* World = GameEngine->GetGameWorld();
if (World)
{
ULocalPlayer *Player = GEngine->GetFirstGamePlayer(World);
if (Player)
{
// get the shoter game
AShooterGameState* const GameState = Cast<AShooterGameState>(Player->PlayerController->GetWorld()->GameState);
RankedPlayerMap Players;
GameState->GetRankedMap(0, Players);
bool bNeedsComma = false;
for (auto It = Players.CreateIterator(); It; ++It)
{
if (bNeedsComma)
{
ScoreboardStr += TEXT(" ,");
}
ScoreboardStr += FString::Printf(TEXT(" { \"n\" : \"%s\" , \"k\" : \"%d\" , \"d\" : \"%d\" }"), *It.Value()->GetShortPlayerName(), It.Value()->GetKills(), It.Value()->GetDeaths());
bNeedsComma = true;
}
}
ScoreboardStr += TEXT(" ] }");
Response.Add(TEXT("Content-Type"), TEXT("text/html; charset=utf-8"));
Response.Add(TEXT("Body"), ScoreboardStr);
}
}
}
}
virtual void RegisterNets(FKismetFunctionContext& Context, UEdGraphNode* Node)
{
FNodeHandlingFunctor::RegisterNets(Context, Node);
const FString BaseNetName = Context.NetNameMap->MakeValidName(Node);
// Create a term to store a bool that determines if we're in the first execution of the node or not
FBPTerminal* FirstRunTerm = Context.CreateLocalTerminal();
FirstRunTerm->Type.PinCategory = CompilerContext.GetSchema()->PC_Boolean;
FirstRunTerm->Source = Node;
FirstRunTerm->Name = BaseNetName + TEXT("_FirstRun");
FirstRunTermMap.Add(Node, FirstRunTerm);
UK2Node_MultiGate* GateNode = Cast<UK2Node_MultiGate>(Node);
// If there is already a data node from expansion phase
if (!GateNode || !GateNode->DataNode)
{
FBPTerminal* DataTerm = Context.CreateLocalTerminal();
DataTerm->Type.PinCategory = CompilerContext.GetSchema()->PC_Int;
DataTerm->Source = Node;
DataTerm->Name = BaseNetName + TEXT("_Data");
DataTermMap.Add(Node, DataTerm);
}
FFunctionScopedTerms& FuncLocals = FunctionTermMap.FindOrAdd(Context.Function);
// Create a local scratch bool for run-time if there isn't already one
if (!FuncLocals.GenericBoolTerm)
{
FuncLocals.GenericBoolTerm = Context.CreateLocalTerminal();
FuncLocals.GenericBoolTerm->Type.PinCategory = CompilerContext.GetSchema()->PC_Boolean;
FuncLocals.GenericBoolTerm->Source = Node;
FuncLocals.GenericBoolTerm->Name = BaseNetName + TEXT("_ScratchBool");
}
// Create a local scratch int for run-time index tracking if there isn't already one
if (!FuncLocals.IndexTerm)
{
FuncLocals.IndexTerm = Context.CreateLocalTerminal();
FuncLocals.IndexTerm->Type.PinCategory = CompilerContext.GetSchema()->PC_Int;
FuncLocals.IndexTerm->Source = Node;
FuncLocals.IndexTerm->Name = BaseNetName + TEXT("_ScratchIndex");
}
}
void InitializeInjectedNodes(UBehaviorTreeGraphNode* GraphNode, UBTCompositeNode* RootNode, uint16 ExecutionIndex, uint8 TreeDepth, int32 ChildIdx)
{
TMap<UBehaviorTreeGraphNode_CompositeDecorator*, FIntIntPair> CompositeMap;
TArray<UBTDecorator*> DecoratorInstances;
TArray<FBTDecoratorLogic> DecoratorOperations;
for (int32 i = 0; i < GraphNode->Decorators.Num(); i++)
{
UBehaviorTreeGraphNode* MyNode = GraphNode->Decorators[i];
if (MyNode == NULL || !MyNode->bInjectedNode)
{
continue;
}
UBehaviorTreeGraphNode_Decorator* MyDecoratorNode = Cast<UBehaviorTreeGraphNode_Decorator>(MyNode);
UBehaviorTreeGraphNode_CompositeDecorator* MyCompositeNode = Cast<UBehaviorTreeGraphNode_CompositeDecorator>(MyNode);
if (MyDecoratorNode)
{
MyDecoratorNode->CollectDecoratorData(DecoratorInstances, DecoratorOperations);
}
else if (MyCompositeNode)
{
MyCompositeNode->SetDecoratorData(RootNode, ChildIdx);
FIntIntPair RangeData;
RangeData.FirstIdx = DecoratorInstances.Num();
MyCompositeNode->CollectDecoratorData(DecoratorInstances, DecoratorOperations);
RangeData.LastIdx = DecoratorInstances.Num() - 1;
CompositeMap.Add(MyCompositeNode, RangeData);
}
}
for (int32 i = 0; i < DecoratorInstances.Num(); i++)
{
DecoratorInstances[i]->InitializeNode(RootNode, ExecutionIndex, 0, TreeDepth);
DecoratorInstances[i]->InitializeDecorator(ChildIdx);
ExecutionIndex++;
}
// initialize composite decorators
for (TMap<UBehaviorTreeGraphNode_CompositeDecorator*, FIntIntPair>::TIterator It(CompositeMap); It; ++It)
{
UBehaviorTreeGraphNode_CompositeDecorator* Node = It.Key();
const FIntIntPair& PairInfo = It.Value();
if (DecoratorInstances.IsValidIndex(PairInfo.FirstIdx) &&
DecoratorInstances.IsValidIndex(PairInfo.LastIdx))
{
Node->FirstExecutionIndex = DecoratorInstances[PairInfo.FirstIdx]->GetExecutionIndex();
Node->LastExecutionIndex = DecoratorInstances[PairInfo.LastIdx]->GetExecutionIndex();
}
}
}
bool FStringFormattingTestNamedEscaped::RunTest( const FString& Parameters )
{
TMap<FString, FStringFormatArg> Args;
Args.Add(TEXT("Argument1"), TEXT("Replacement 1"));
const TCHAR* Pattern = TEXT("This is some text containing brace and an arg, `{ Argument1 } and {Argument1}.");
const TCHAR* Result = TEXT("This is some text containing brace and an arg, { Argument1 } and Replacement 1.");
return TestStrings(*this, Pattern, Args, Result);
}
bool FStringFormattingTestNamedNonExistent::RunTest( const FString& Parameters )
{
TMap<FString, FStringFormatArg> Args;
Args.Add(TEXT("Argument1"), TEXT("Replacement 1"));
const TCHAR* Pattern = TEXT("This is some text containing a non-existent arg { Argument2 }");
const TCHAR* Result = TEXT("This is some text containing a non-existent arg { Argument2 }");
return TestStrings(*this, Pattern, Args, Result);
}
bool FStringFormattingTestNamedInvalid::RunTest( const FString& Parameters )
{
TMap<FString, FStringFormatArg> Args;
Args.Add(TEXT("Argument1"), TEXT("Replacement 1"));
const TCHAR* Pattern = TEXT("This is some text containing an invalid arg {Argument1 1} { a8f7690-23\\ {} }");
const TCHAR* Result = TEXT("This is some text containing an invalid arg {Argument1 1} { a8f7690-23\\ {} }");
return TestStrings(*this, Pattern, Args, Result);
}
void PatchCDB(const char* runlist, const char* runlist1400, const char* srcOCDBPath="alien://folder=/alice/data/2016/OCDB", const char* destOCDBPath="alien://folder=/alice/cern.ch/user/l/laphecet/OCDBCH3L")
{
// function to patch the OCDB MUON/Calib/HV for the swap of CH3L Q2S1 and Q2S2
// runlist = full list of runs where Chamber03Left/Quad2Sect1 has an HV problem (trips, too low, plus the 1400 V
// below)
// runlist1400 = list of runs where Chamber03Left/Quad2Sect1 was struggling at 1400 V
// for the runs in runlist1400, the HV will be forced to zero for that sector
// note that Chamber03Left/Quad2Sect1 = Chamber02Left/Quad1Sect0 in DCS alias world
AliAnalysisTriggerScalers ts(runlist,srcOCDBPath);
std::vector<int> vrunlist = ts.GetRunList();
AliAnalysisTriggerScalers ts1400(runlist1400,srcOCDBPath);
std::vector<int> vrunlist1400 = ts1400.GetRunList();
AliCDBManager* man = AliCDBManager::Instance();
TObjString sector2("MchHvLvLeft/Chamber02Left/Quad1Sect0.actual.vMon");
TObjString sector1("MchHvLvLeft/Chamber02Left/Quad1Sect1.actual.vMon");
for ( auto r : vrunlist )
{
man->SetDefaultStorage(srcOCDBPath);
man->SetRun(r);
std::cout << "Run " << r << std::endl;
AliCDBEntry* entry = man->Get("MUON/Calib/HV");
TMap* hvmap = static_cast<TMap*>(entry->GetObject()->Clone());
TPair* p1 = hvmap->RemoveEntry(§or2);
if ( std::find(vrunlist1400.begin(),vrunlist1400.end(),r) != vrunlist1400.end() )
{
TObjArray* a1 = static_cast<TObjArray*>(p1->Value());
AliDCSValue* first = static_cast<AliDCSValue*>(a1->First());
AliDCSValue* last = static_cast<AliDCSValue*>(a1->Last());
a1->Delete();
a1->Add(new AliDCSValue(0.0f,first->GetTimeStamp()));
a1->Add(new AliDCSValue(0.0f,last->GetTimeStamp()));
}
TPair* p2 = hvmap->RemoveEntry(§or1);
hvmap->Add(new TObjString(sector2),p2->Value());
hvmap->Add(new TObjString(sector1),p1->Value());
delete p1->Key();
delete p2->Key();
man->SetDefaultStorage(destOCDBPath);
hvmap->SetUniqueID( hvmap->GetUniqueID() | ( 1 << 9 ) );
AliMUONCDB::WriteToCDB(hvmap,"MUON/Calib/HV",r,r,"Patched for CH3L Quad2Sect1 vs 0 swapping","L. Aphecetche");
man->ClearCache();
}
}
void FBlueprintCompileReinstancer::GenerateFieldMappings(TMap<UObject*, UObject*>& FieldMapping)
{
check(ClassToReinstance);
FieldMapping.Empty();
for (auto& Prop : PropertyMap)
{
FieldMapping.Add(Prop.Value, FindField<UProperty>(ClassToReinstance, *Prop.Key.ToString()));
}
for (auto& Func : FunctionMap)
{
UFunction* NewFunction = ClassToReinstance->FindFunctionByName(Func.Key, EIncludeSuperFlag::ExcludeSuper);
FieldMapping.Add(Func.Value, NewFunction);
}
UObject* NewCDO = ClassToReinstance->GetDefaultObject();
FieldMapping.Add(OriginalCDO, NewCDO);
}
void FLightingBuildInfoStatsPage::GenerateTotals( const TArray< TWeakObjectPtr<UObject> >& InObjects, TMap<FString, FText>& OutTotals ) const
{
if(InObjects.Num())
{
ULightingBuildInfo* TotalEntry = NewObject<ULightingBuildInfo>();
for( auto It = InObjects.CreateConstIterator(); It; ++It )
{
ULightingBuildInfo* Entry = Cast<ULightingBuildInfo>( It->Get() );
TotalEntry->LightingTime += Entry->LightingTime;
TotalEntry->UnmappedTexelsPercentage += Entry->UnmappedTexelsPercentage;
TotalEntry->UnmappedTexelsMemory += Entry->UnmappedTexelsMemory;
TotalEntry->TotalTexelMemory += Entry->TotalTexelMemory;
}
OutTotals.Add( TEXT("LightingTime"), FText::AsNumber( TotalEntry->LightingTime ) );
OutTotals.Add( TEXT("UnmappedTexelsPercentage"), FText::AsNumber( TotalEntry->UnmappedTexelsPercentage ) );
OutTotals.Add( TEXT("UnmappedTexelsMemory"), FText::AsNumber( TotalEntry->UnmappedTexelsMemory ) );
OutTotals.Add( TEXT("TotalTexelMemory"), FText::AsNumber( TotalEntry->TotalTexelMemory ) );
}
}
