FORCEINLINE FString BuildJsonStrFromMap(TMap<FString, FString> Map)
{
FString JsonStr;
TSharedRef< TJsonWriter<TCHAR, TCondensedJsonPrintPolicy<TCHAR> > > JsonWriter = TJsonWriterFactory<TCHAR, TCondensedJsonPrintPolicy<TCHAR> >::Create(&JsonStr);
// Close the writer and finalize the output such that JsonStr has what we want
TArray<FString> keys;
Map.GetKeys(keys);
JsonWriter->WriteObjectStart();
for (int32 k = 0; k < Map.Num(); k++)
{
JsonWriter->WriteValue(keys[k], Map[keys[k]]);
}
JsonWriter->WriteObjectEnd();
JsonWriter->Close();
return JsonStr;
}
TSharedPtr<ITextFormatArgumentModifier> FTextFormatArgumentModifier_PluralForm::Create(const ETextPluralType InPluralType, const FTextFormatString& InArgsString)
{
TMap<FTextFormatString, FTextFormatString> ArgKeyValues;
if (ParseKeyValueArgs(InArgsString, ArgKeyValues))
{
int32 LongestPluralFormStringLen = 0;
bool bDoPluralFormsUseFormatArgs = false;
// Plural forms may contain format markers, so pre-compile all the variants now so that Evaluate doesn't have to (this also lets us validate the plural form strings and fail if they're not correct)
TMap<FTextFormatString, FTextFormat> PluralForms;
PluralForms.Reserve(ArgKeyValues.Num());
for (const auto& Pair : ArgKeyValues)
{
FTextFormat PluralForm = FTextFormat::FromString(FString(Pair.Value.StringLen, Pair.Value.StringPtr));
if (!PluralForm.IsValid())
{
break;
}
LongestPluralFormStringLen = FMath::Max(LongestPluralFormStringLen, Pair.Value.StringLen);
bDoPluralFormsUseFormatArgs |= PluralForm.GetExpressionType() == FTextFormat::EExpressionType::Complex;
PluralForms.Add(Pair.Key, MoveTemp(PluralForm));
}
// Did everything compile?
if (PluralForms.Num() == ArgKeyValues.Num())
{
return MakeShareable(new FTextFormatArgumentModifier_PluralForm(InPluralType, PluralForms, LongestPluralFormStringLen, bDoPluralFormsUseFormatArgs));
}
}
return nullptr;
}
void FIndirectLightingCache::UpdateBlocks(FScene* Scene, FViewInfo* DebugDrawingView, TMap<FIntVector, FBlockUpdateInfo>& BlocksToUpdate)
{
if (BlocksToUpdate.Num() > 0 && !IsInitialized())
{
InitResource();
}
INC_DWORD_STAT_BY(STAT_IndirectLightingCacheUpdates, BlocksToUpdate.Num());
for (TMap<FIntVector, FBlockUpdateInfo>::TIterator It(BlocksToUpdate); It; ++It)
{
UpdateBlock(Scene, DebugDrawingView, It.Value());
}
}
bool FChunkManifestGenerator::SaveAssetRegistry(const FString& SandboxPath)
{
UE_LOG(LogChunkManifestGenerator, Display, TEXT("Saving asset registry."));
// Create asset registry data
FArrayWriter SerializedAssetRegistry;
TMap<FName, FAssetData*> GeneratedAssetRegistryData;
for (auto& AssetData : AssetRegistryData)
{
// Add only assets that have actually been cooked and belong to any chunk
if (AssetData.ChunkIDs.Num() > 0)
{
GeneratedAssetRegistryData.Add(AssetData.ObjectPath, &AssetData);
}
}
AssetRegistry.SaveRegistryData(SerializedAssetRegistry, GeneratedAssetRegistryData, GeneratedAssetRegistryData.Num());
UE_LOG(LogChunkManifestGenerator, Display, TEXT("Generated asset registry num assets %d, size is %5.2fkb"), GeneratedAssetRegistryData.Num(), (float)SerializedAssetRegistry.Num() / 1024.f);
// Save the generated registry for each platform
for (auto Platform : Platforms)
{
FString PlatformSandboxPath = SandboxPath.Replace(TEXT("[Platform]"), *Platform->PlatformName());
FFileHelper::SaveArrayToFile(SerializedAssetRegistry, *PlatformSandboxPath);
}
UE_LOG(LogChunkManifestGenerator, Display, TEXT("Done saving asset registry."));
return true;
}
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 );
}
}
}
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;
}
MatchmakerModels::Region PlayFab::MatchmakerModels::readRegionFromValue(const TSharedPtr<FJsonValue>& value)
{
static TMap<FString, Region> _RegionMap;
if (_RegionMap.Num() == 0)
{
// Auto-generate the map on the first use
_RegionMap.Add(TEXT("USCentral"), RegionUSCentral);
_RegionMap.Add(TEXT("USEast"), RegionUSEast);
_RegionMap.Add(TEXT("EUWest"), RegionEUWest);
_RegionMap.Add(TEXT("Singapore"), RegionSingapore);
_RegionMap.Add(TEXT("Japan"), RegionJapan);
_RegionMap.Add(TEXT("Brazil"), RegionBrazil);
_RegionMap.Add(TEXT("Australia"), RegionAustralia);
}
if(value.IsValid())
{
auto output = _RegionMap.Find(value->AsString());
if (output != nullptr)
return *output;
}
return RegionUSCentral; // Basically critical fail
}
bool FProjectManager::LoadModulesForProject( const ELoadingPhase::Type LoadingPhase )
{
DECLARE_SCOPE_CYCLE_COUNTER(TEXT("Loading Game Modules"), STAT_GameModule, STATGROUP_LoadTime);
bool bSuccess = true;
if ( CurrentProject.IsValid() )
{
TMap<FName, EModuleLoadResult> ModuleLoadFailures;
FModuleDescriptor::LoadModulesForPhase(LoadingPhase, CurrentProject->Modules, ModuleLoadFailures);
if ( ModuleLoadFailures.Num() > 0 )
{
FText FailureMessage;
for ( auto FailureIt = ModuleLoadFailures.CreateConstIterator(); FailureIt; ++FailureIt )
{
const EModuleLoadResult FailureReason = FailureIt.Value();
if( FailureReason != EModuleLoadResult::Success )
{
const FText TextModuleName = FText::FromName(FailureIt.Key());
if ( FailureReason == EModuleLoadResult::FileNotFound )
{
FailureMessage = FText::Format( LOCTEXT("PrimaryGameModuleNotFound", "The game module '{0}' could not be found. Please ensure that this module exists and that it is compiled."), TextModuleName );
}
else if ( FailureReason == EModuleLoadResult::FileIncompatible )
{
FailureMessage = FText::Format( LOCTEXT("PrimaryGameModuleIncompatible", "The game module '{0}' does not appear to be up to date. This may happen after updating the engine. Please recompile this module and try again."), TextModuleName );
}
else if ( FailureReason == EModuleLoadResult::FailedToInitialize )
{
FailureMessage = FText::Format( LOCTEXT("PrimaryGameModuleFailedToInitialize", "The game module '{0}' could not be successfully initialized after it was loaded."), TextModuleName );
}
else if ( FailureReason == EModuleLoadResult::CouldNotBeLoadedByOS )
{
FailureMessage = FText::Format( LOCTEXT("PrimaryGameModuleCouldntBeLoaded", "The game module '{0}' could not be loaded. There may be an operating system error or the module may not be properly set up."), TextModuleName );
}
else
{
ensure(0); // If this goes off, the error handling code should be updated for the new enum values!
FailureMessage = FText::Format( LOCTEXT("PrimaryGameModuleGenericLoadFailure", "The game module '{0}' failed to load for an unspecified reason. Please report this error."), TextModuleName );
}
// Just report the first error
break;
}
}
FMessageDialog::Open(EAppMsgType::Ok, FailureMessage);
bSuccess = false;
}
}
return bSuccess;
}
bool FProvider::UpdateFileStateCache(
const TMap<FString, TArray<FFileRevisionRef> >& InFileRevisionsMap
)
{
for (auto It(InFileRevisionsMap.CreateConstIterator()); It; ++It)
{
FFileStateRef FileState = GetFileStateFromCache(It.Key());
FileState->SetHistory(It.Value());
FileState->SetTimeStamp(FDateTime::Now());
}
return InFileRevisionsMap.Num() > 0;
}
bool FModuleManager::IsModuleUpToDate( const FName InModuleName ) const
{
TMap<FName, FString> ModulePathMap;
FindModulePaths(*InModuleName.ToString(), ModulePathMap);
if(ModulePathMap.Num() != 1)
{
return false;
}
return CheckModuleCompatibility(*TMap<FName, FString>::TConstIterator(ModulePathMap).Value());
}
static bool UpdateCachedStates(const TMap<FString, EPerforceState::Type>& InResults)
{
FPerforceSourceControlModule& PerforceSourceControl = FPerforceSourceControlModule::Get();
for(TMap<FString, EPerforceState::Type>::TConstIterator It(InResults); It; ++It)
{
TSharedRef<FPerforceSourceControlState, ESPMode::ThreadSafe> State = PerforceSourceControl.GetProvider().GetStateInternal(It.Key());
State->SetState(It.Value());
State->TimeStamp = FDateTime::Now();
}
return InResults.Num() > 0;
}
void FStatsMemoryDumpCommand::GenerateMemoryUsageReport( const TMap<uint64, FAllocationInfo>& AllocationMap )
{
if( AllocationMap.Num() == 0 )
{
UE_LOG( LogStats, Warning, TEXT( "There are no allocations, make sure memory profiler is enabled" ) );
}
else
{
ProcessingUObjectAllocations( AllocationMap );
ProcessingScopedAllocations( AllocationMap );
}
}
void FGAGameEffectContainer::RemoveEffect(FGAGameEffectHandle& HandleIn)
{
EGAEffectAggregation aggregatiopn = HandleIn.GetEffectRef().GameEffect->EffectAggregation;
UObject* Instigator = HandleIn.GetContextRef().Instigator.Get();
TSharedPtr<FGAGameEffect> effect = ActiveEffects.FindAndRemoveChecked(HandleIn);
if (effect.IsValid())
{
switch (aggregatiopn)
{
case EGAEffectAggregation::AggregateByInstigator:
{
TMap<FGAGameEffectHandle, TSharedPtr<FGAGameEffect>>* effects = InstigatorEffects.Find(Instigator);
TMap<FName, TSet<FGAGameEffectHandle>>* EffectByClass = InstigatorEffectHandles.Find(Instigator);
if (EffectByClass)
{
//Probabaly need another path for removing just single effect from stack.
EffectByClass->Remove(HandleIn.GetEffectSpec()->GetFName());
}
if (effects)
{
effects->FindAndRemoveChecked(HandleIn);
if (effects->Num() == 0)
{
InstigatorEffects.Remove(Instigator);
}
}
break;
}
case EGAEffectAggregation::AggregateByTarget:
{
//TargetEffects.FindAndRemoveChecked(HandleIn);
TSet<FGAGameEffectHandle>* Handles = TargetEffectByType.Find(HandleIn.GetEffectSpec()->GetFName());
//check aggregation type to know which effect to remove exactly ?
TargetEffectByType.Remove(HandleIn.GetEffectSpec()->GetFName());
break;
}
}
for (FGAGameEffectModifier& Modifier : effect->GameEffect->Modifiers)
{
if (Modifier.Attribute.IsValid())
{
FGAAttributeBase* Attribute = OwningComp->GetAttribute(Modifier.Attribute);
if (Attribute)
{
Attribute->RemoveBonus(HandleIn);
}
}
}
UE_LOG(GameAttributesEffects, Log, TEXT("FGAGameEffectContainer:: Removing Effect"))
effect.Reset();
}
}
static bool UpdateCachedLocalizationStates(const TMap<FLocalizationServiceTranslationIdentifier, TSharedRef<FOneSkyLocalizationServiceState, ESPMode::ThreadSafe>, FDefaultSetAllocator, FLocalizationServiceTranslationIdentifierKeyFuncs<TSharedRef<FOneSkyLocalizationServiceState, ESPMode::ThreadSafe>>>& InResults)
{
FOneSkyLocalizationServiceModule& OneSkyLocalizationService = FOneSkyLocalizationServiceModule::Get();
for (auto It = InResults.CreateConstIterator(); It; ++It)
{
TSharedRef<FOneSkyLocalizationServiceState, ESPMode::ThreadSafe> State = OneSkyLocalizationService.GetProvider().GetStateInternal(It.Key());
State->SetState(It.Value()->GetState());
State->SetTranslation(It.Value()->GetTranslationString());
State->TimeStamp = FDateTime::Now();
}
return InResults.Num() > 0;
}
void FGAGameEffectContainer::RemoveEffect(FGAGameEffectHandle& HandleIn)
{
EGAEffectAggregation aggregatiopn = HandleIn.GetEffectRef().GameEffect->EffectAggregation;
UObject* Instigator = HandleIn.GetContextRef().Instigator.Get();
TSharedPtr<FGAGameEffect> effect = ActiveEffects.FindAndRemoveChecked(HandleIn);
if (effect.IsValid())
{
switch (aggregatiopn)
{
case EGAEffectAggregation::AggregateByInstigator:
{
TMap<FGAGameEffectHandle, TSharedPtr<FGAGameEffect>>* effects = InstigatorEffects.Find(Instigator);
TMap<UClass*, FGAGameEffectHandle>* EffectByClass = InstigatorEffectHandles.Find(Instigator);
if (EffectByClass)
{
EffectByClass->Remove(HandleIn.GetEffectSpec()->StaticClass());
}
if (effects)
{
effects->FindAndRemoveChecked(HandleIn);
if (effects->Num() == 0)
{
InstigatorEffects.Remove(Instigator);
}
}
break;
}
case EGAEffectAggregation::AggregateByTarget:
{
TargetEffects.FindAndRemoveChecked(HandleIn);
break;
}
}
for (FGAGameEffectModifier& Modifier : effect->GameEffect->Modifiers)
{
if (Modifier.Attribute.IsValid())
{
FGAAttributeBase* Attribute = OwningComp->GetAttribute(Modifier.Attribute);
if (Attribute)
{
Attribute->RemoveBonus(HandleIn);
}
}
}
UE_LOG(GameAttributesEffects, Log, TEXT("FGAGameEffectContainer:: Removing Effect"))
effect.Reset();
}
}
FText FWidgetBlueprintApplicationModes::GetLocalizedMode(const FName InMode)
{
static TMap< FName, FText > LocModes;
if ( LocModes.Num() == 0 )
{
LocModes.Add(DesignerMode, NSLOCTEXT("WidgetBlueprintModes", "DesignerMode", "Designer"));
LocModes.Add(GraphMode, NSLOCTEXT("WidgetBlueprintModes", "GraphMode", "Graph"));
}
check(InMode != NAME_None);
const FText* OutDesc = LocModes.Find(InMode);
check(OutDesc);
return *OutDesc;
}
void PackageAutoSaverJson::SaveRestoreFile(const bool bRestoreEnabled, const TMap< TWeakObjectPtr<UPackage>, FString >& DirtyPackages)
{
TSharedPtr<FJsonObject> RootObject = MakeShareable(new FJsonObject);
RootObject->SetBoolField(TagRestoreEnabled, bRestoreEnabled);
TArray< TSharedPtr<FJsonValue> > PackagesThatCanBeRestored;
// Only bother populating the list of packages if the restore is enabled
if(bRestoreEnabled)
{
PackagesThatCanBeRestored.Reserve(DirtyPackages.Num());
// Build up the array of package names with auto-saves that can be restored
for(auto It = DirtyPackages.CreateConstIterator(); It; ++It)
{
const TWeakObjectPtr<UPackage>& Package = It.Key();
const FString& AutoSavePath = It.Value();
UPackage* const PackagePtr = Package.Get();
if(PackagePtr && !AutoSavePath.IsEmpty())
{
const FString& PackagePathName = PackagePtr->GetPathName();
TSharedPtr<FJsonObject> EntryObject = MakeShareable(new FJsonObject);
EntryObject->SetStringField(TagPackagePathName, PackagePathName);
EntryObject->SetStringField(TagAutoSavePath, AutoSavePath);
TSharedPtr<FJsonValue> EntryValue = MakeShareable(new FJsonValueObject(EntryObject));
PackagesThatCanBeRestored.Add(EntryValue);
}
}
}
RootObject->SetArrayField(TagPackages, PackagesThatCanBeRestored);
const FString Filename = GetRestoreFilename(true);
FArchive* const FileAr = IFileManager::Get().CreateFileWriter(*Filename, FILEWRITE_EvenIfReadOnly);
if(FileAr)
{
TSharedRef<FStringWriter> Writer = FStringWriterFactory::Create(FileAr);
FJsonSerializer::Serialize(RootObject.ToSharedRef(), Writer);
FileAr->Close();
}
}
bool GetBoneReductionData( const USkeletalMesh* SkeletalMesh, int32 DesiredLOD, TMap<FBoneIndexType, FBoneIndexType> &OutBonesToReplace ) override
{
const TArray<FMeshBoneInfo> & RefBoneInfo = SkeletalMesh->RefSkeleton.GetRefBoneInfo();
USkeleton* Skeleton = SkeletalMesh->Skeleton;
if (Skeleton)
{
TArray<FBoneIndexType> BoneIndicesToRemove;
// it accumulate from LOD 0 -> LOD N if N+1 is DesiredLOD
// since we don't like to keep the bones that weren't included in (LOD-1)
for ( int LODIndex=0; LODIndex < DesiredLOD && Skeleton->BoneReductionSettingsForLODs.Num() > LODIndex; ++LODIndex )
{
// first gather indices. we don't want to add bones to replace if that "to-be-replace" will be removed as well
for (int32 Index = 0; Index < Skeleton->BoneReductionSettingsForLODs[LODIndex].BonesToRemove.Num(); ++Index)
{
int32 BoneIndex = SkeletalMesh->RefSkeleton.FindBoneIndex(Skeleton->BoneReductionSettingsForLODs[LODIndex].BonesToRemove[Index]);
// we don't allow root to be removed
if ( BoneIndex > 0 )
{
BoneIndicesToRemove.AddUnique(BoneIndex);
}
}
}
// now make sure the parent isn't the one to be removed, find the one that won't be removed
for (int32 Index = 0; Index < BoneIndicesToRemove.Num(); ++Index)
{
int32 BoneIndex = BoneIndicesToRemove[Index];
int32 ParentIndex = RefBoneInfo[BoneIndex].ParentIndex;
while (BoneIndicesToRemove.Contains(ParentIndex))
{
ParentIndex = RefBoneInfo[ParentIndex].ParentIndex;
}
OutBonesToReplace.Add(BoneIndex, ParentIndex);
}
}
return ( OutBonesToReplace.Num() > 0 );
}
/**
* Compare two object property maps
* @param OrigName The name of the original object being compared against
* @param OrigMap The property map for the object
* @param CmpName The name of the object to compare
* @param CmpMap The property map for the object to compare
*/
static bool ComparePropertyMaps(FName OrigName, TMap<FString, FString>& OrigMap, FName CmpName, FPropertiesMap& CmpMap, FCompilerResultsLog& Results)
{
if (OrigMap.Num() != CmpMap.Num())
{
Results.Error( *FString::Printf(TEXT("Objects have a different number of properties (%d vs %d)"), OrigMap.Num(), CmpMap.Num()) );
return false;
}
bool bMatch = true;
for (auto PropIt = OrigMap.CreateIterator(); PropIt; ++PropIt)
{
FString Key = PropIt.Key();
FString Val = PropIt.Value();
const FString* CmpValue = CmpMap.Find(Key);
// Value is missing
if (CmpValue == NULL)
{
bMatch = false;
Results.Error( *FString::Printf(TEXT("Property is missing in object being compared: (%s %s)"), *Key, *Val) );
break;
}
else if (Val != *CmpValue)
{
// string out object names and retest
FString TmpCmp(*CmpValue);
TmpCmp.ReplaceInline(*CmpName.ToString(), TEXT(""));
FString TmpVal(Val);
TmpVal.ReplaceInline(*OrigName.ToString(), TEXT(""));
if (TmpCmp != TmpVal)
{
bMatch = false;
Results.Error( *FString::Printf(TEXT("Object properties do not match: %s (%s vs %s)"), *Key, *Val, *(*CmpValue)) );
break;
}
}
}
return bMatch;
}
//------------------------------------------------------------------------------
FText const& FEditorCategoryUtils::GetCommonCategory(const FCommonEditorCategory::EValue CategoryId)
{
static TMap<FCommonEditorCategory::EValue, FString> CommonCategoryKeys;
if (CommonCategoryKeys.Num() == 0)
{
CommonCategoryKeys.Add(FCommonEditorCategory::AI, "AI");
CommonCategoryKeys.Add(FCommonEditorCategory::Animation, "Animation");
CommonCategoryKeys.Add(FCommonEditorCategory::Audio, "Audio");
CommonCategoryKeys.Add(FCommonEditorCategory::Development, "Development");
CommonCategoryKeys.Add(FCommonEditorCategory::Effects, "Effects");
CommonCategoryKeys.Add(FCommonEditorCategory::Gameplay, "Gameplay");
CommonCategoryKeys.Add(FCommonEditorCategory::Input, "Input");
CommonCategoryKeys.Add(FCommonEditorCategory::Math, "Math");
CommonCategoryKeys.Add(FCommonEditorCategory::Networking, "Networking");
CommonCategoryKeys.Add(FCommonEditorCategory::Pawn, "Pawn");
CommonCategoryKeys.Add(FCommonEditorCategory::Rendering, "Rendering");
CommonCategoryKeys.Add(FCommonEditorCategory::Utilities, "Utilities");
CommonCategoryKeys.Add(FCommonEditorCategory::Delegates, "Delegates");
CommonCategoryKeys.Add(FCommonEditorCategory::Variables, "Variables");
CommonCategoryKeys.Add(FCommonEditorCategory::Class, "Class");
CommonCategoryKeys.Add(FCommonEditorCategory::UserInterface, "UserInterface");
CommonCategoryKeys.Add(FCommonEditorCategory::AnimNotify, "AnimNotify");
CommonCategoryKeys.Add(FCommonEditorCategory::BranchPoint, "BranchPoint");
CommonCategoryKeys.Add(FCommonEditorCategory::FlowControl, "FlowControl");
CommonCategoryKeys.Add(FCommonEditorCategory::Transformation, "Transformation");
CommonCategoryKeys.Add(FCommonEditorCategory::String, "String");
CommonCategoryKeys.Add(FCommonEditorCategory::Text, "Text");
CommonCategoryKeys.Add(FCommonEditorCategory::Name, "Name");
CommonCategoryKeys.Add(FCommonEditorCategory::Enum, "Enum");
CommonCategoryKeys.Add(FCommonEditorCategory::Struct, "Struct");
CommonCategoryKeys.Add(FCommonEditorCategory::Macro, "Macro");
}
if (FString* CategoryKey = CommonCategoryKeys.Find(CategoryId))
{
return FEditorCategoryUtilsImpl::GetCategory(*CategoryKey);
}
return FText::GetEmpty();
}
void UAnimPreviewInstance::UpdateCurveController()
{
// evaluate the curve data first
UAnimSequenceBase* CurrentSequence = Cast<UAnimSequenceBase>(CurrentAsset);
if (CurrentSequence && CurrentSkeleton)
{
TMap<FName, FTransform> ActiveCurves;
CurrentSequence->RawCurveData.EvaluateTransformCurveData(CurrentSkeleton, ActiveCurves, CurrentTime, 1.f);
// make sure those curves exists in the bone controller, otherwise problem
if ( ActiveCurves.Num() > 0 )
{
for(auto& SingleBoneController : CurveBoneControllers)
{
// make sure the curve exists
FName CurveName = SingleBoneController.BoneToModify.BoneName;
// we should add extra key to front and back whenever animation length changes or so.
// animation length change requires to bake down animation first
// this will make sure all the keys that were embedded at the start/end will automatically be backed to the data
const FTransform* Value = ActiveCurves.Find(CurveName);
if (Value)
{
// apply this change
SingleBoneController.Translation = Value->GetTranslation();
SingleBoneController.Scale = Value->GetScale3D();
// sasd we're converting twice
SingleBoneController.Rotation = Value->GetRotation().Rotator();
}
}
}
else
{
// should match
ensure (CurveBoneControllers.Num() == 0);
CurveBoneControllers.Empty();
}
}
}
bool UDiffAssetsCommandlet::ExportFile(const FString& Filename, const TArray<UObject *>& LoadedObjects)
{
FString Extension = TEXT("t3d");
FStringOutputDevice Buffer;
const FExportObjectInnerContext Context;
for (int32 Index = 0; Index < LoadedObjects.Num(); Index++)
{
UExporter* Exporter = UExporter::FindExporter( LoadedObjects[Index], *Extension );
if (!Exporter)
{
UE_LOG(LogDiffAssetsCommandlet, Warning, TEXT("Could not find exporter."));
return false;
}
UExporter::ExportToOutputDevice( &Context, LoadedObjects[Index], Exporter, Buffer, *Extension, 0, PPF_ExportsNotFullyQualified, false );
TMap<FString,FString> NativePropertyValues;
if ( LoadedObjects[Index]->GetNativePropertyValues(NativePropertyValues) && NativePropertyValues.Num())
{
int32 LargestKey = 0;
for ( TMap<FString,FString>::TIterator It(NativePropertyValues); It; ++It )
{
LargestKey = FMath::Max(LargestKey, It.Key().Len());
}
for ( TMap<FString,FString>::TIterator It(NativePropertyValues); It; ++It )
{
Buffer.Logf(TEXT(" %s=%s"), *It.Key().RightPad(LargestKey), *It.Value());
}
}
}
if (!Buffer.Len())
{
UE_LOG(LogDiffAssetsCommandlet, Warning, TEXT("No text was exported!"));
return false;
}
if( !FFileHelper::SaveStringToFile( Buffer, *Filename ) )
{
UE_LOG(LogDiffAssetsCommandlet, Warning, TEXT("Could not write %s"), *Filename);
return false;
}
return true;
}
bool FDesktopPlatformBase::GetDefaultEngineIdentifier(FString &OutId)
{
TMap<FString, FString> Installations;
EnumerateEngineInstallations(Installations);
bool bRes = false;
if (Installations.Num() > 0)
{
// Default to the first install
TMap<FString, FString>::TConstIterator Iter(Installations);
OutId = Iter.Key();
++Iter;
// Try to find the most preferred install
for(; Iter; ++Iter)
{
if(IsPreferredEngineIdentifier(Iter.Key(), OutId))
{
OutId = Iter.Key();
}
}
}
return bRes;
}
bool FChunkManifestGenerator::SaveAssetRegistry(const FString& SandboxPath, const TArray<FName>* IgnorePackageList)
{
UE_LOG(LogChunkManifestGenerator, Display, TEXT("Saving asset registry."));
TSet<FName> IgnorePackageSet;
if (IgnorePackageList != nullptr)
{
for (const auto& IgnorePackage : *IgnorePackageList)
{
IgnorePackageSet.Add(IgnorePackage);
}
}
// Create asset registry data
TArray<FName> MapList;
FArrayWriter SerializedAssetRegistry;
SerializedAssetRegistry.SetFilterEditorOnly(true);
TMap<FName, FAssetData*> GeneratedAssetRegistryData;
for (auto& AssetData : AssetRegistryData)
{
if (IgnorePackageSet.Contains(AssetData.PackageName))
{
continue;
}
// Add only assets that have actually been cooked and belong to any chunk
if (AssetData.ChunkIDs.Num() > 0)
{
GeneratedAssetRegistryData.Add(AssetData.PackageName, &AssetData);
if (ContainsMap(AssetData.PackageName))
{
MapList.Add(AssetData.PackageName);
}
}
}
AssetRegistry.SaveRegistryData(SerializedAssetRegistry, GeneratedAssetRegistryData, &MapList);
UE_LOG(LogChunkManifestGenerator, Display, TEXT("Generated asset registry num assets %d, size is %5.2fkb"), GeneratedAssetRegistryData.Num(), (float)SerializedAssetRegistry.Num() / 1024.f);
auto CookerFileOrderString = CreateCookerFileOrderString(GeneratedAssetRegistryData, MapList);
// Save the generated registry for each platform
for (auto Platform : Platforms)
{
FString PlatformSandboxPath = SandboxPath.Replace(TEXT("[Platform]"), *Platform->PlatformName());
FFileHelper::SaveArrayToFile(SerializedAssetRegistry, *PlatformSandboxPath);
if (CookerFileOrderString.Len())
{
auto OpenOrderFilename = FString::Printf(TEXT("%sBuild/%s/FileOpenOrder/CookerOpenOrder.log"), *FPaths::GameDir(), *Platform->PlatformName());
FFileHelper::SaveStringToFile(CookerFileOrderString, *OpenOrderFilename);
}
}
UE_LOG(LogChunkManifestGenerator, Display, TEXT("Done saving asset registry."));
return true;
}
// FStaticLightingTextureMapping interface
void FStaticMeshStaticLightingTextureMapping::Apply(FQuantizedLightmapData* QuantizedData, const TMap<ULightComponent*,FShadowMapData2D*>& ShadowMapData)
{
UStaticMeshComponent* StaticMeshComponent = Primitive.Get();
if (StaticMeshComponent)
{
// Should have happened at a higher level
check(!StaticMeshComponent->IsRegistered());
// The rendering thread reads from LODData and IrrelevantLights, therefore
// the component must have finished detaching from the scene on the rendering
// thread before it is safe to continue.
check(StaticMeshComponent->AttachmentCounter.GetValue() == 0);
// Ensure LODData has enough entries in it, free not required.
StaticMeshComponent->SetLODDataCount(LODIndex + 1, StaticMeshComponent->StaticMesh->GetNumLODs());
FStaticMeshComponentLODInfo& ComponentLODInfo = StaticMeshComponent->LODData[LODIndex];
ELightMapPaddingType PaddingType = GAllowLightmapPadding ? LMPT_NormalPadding : LMPT_NoPadding;
const bool bHasNonZeroData = (QuantizedData != NULL && QuantizedData->HasNonZeroData());
// We always create a light map if the surface either has any non-zero lighting data, or if the surface has a shadow map. The runtime
// shaders are always expecting a light map in the case of a shadow map, even if the lighting is entirely zero. This is simply to reduce
// the number of shader permutations to support in the very unlikely case of a unshadowed surfaces that has lighting values of zero.
const bool bNeedsLightMap = bHasNonZeroData || ShadowMapData.Num() > 0 || Mesh->RelevantLights.Num() > 0 || (QuantizedData != NULL && QuantizedData->bHasSkyShadowing);
if (bNeedsLightMap)
{
// Create a light-map for the primitive.
ComponentLODInfo.LightMap = FLightMap2D::AllocateLightMap(
StaticMeshComponent,
QuantizedData,
StaticMeshComponent->Bounds,
PaddingType,
LMF_Streamed
);
}
else
{
ComponentLODInfo.LightMap = NULL;
}
if (ShadowMapData.Num() > 0)
{
ComponentLODInfo.ShadowMap = FShadowMap2D::AllocateShadowMap(
StaticMeshComponent,
ShadowMapData,
StaticMeshComponent->Bounds,
PaddingType,
SMF_Streamed
);
}
else
{
ComponentLODInfo.ShadowMap = NULL;
}
// Build the list of statically irrelevant lights.
// IrrelevantLights was cleared in InvalidateLightingCacheDetailed
for(int32 LightIndex = 0;LightIndex < Mesh->RelevantLights.Num();LightIndex++)
{
const ULightComponent* Light = Mesh->RelevantLights[LightIndex];
// Check if the light is stored in the light-map.
const bool bIsInLightMap = ComponentLODInfo.LightMap && ComponentLODInfo.LightMap->LightGuids.Contains(Light->LightGuid);
// Check if the light is stored in the shadow-map.
const bool bIsInShadowMap = ComponentLODInfo.ShadowMap && ComponentLODInfo.ShadowMap->LightGuids.Contains(Light->LightGuid);
// Add the light to the statically irrelevant light list if it is in the potentially relevant light list, but didn't contribute to the light-map.
if(!bIsInLightMap && !bIsInShadowMap)
{
StaticMeshComponent->IrrelevantLights.AddUnique(Light->LightGuid);
}
}
StaticMeshComponent->bHasCachedStaticLighting = true;
// Mark the primitive's package as dirty.
StaticMeshComponent->MarkPackageDirty();
}
}
void FEngineAnalytics::Initialize()
{
checkf(!bIsInitialized, TEXT("FEngineAnalytics::Initialize called more than once."));
check(GEngine);
// this will only be true for builds that have editor support (currently PC, Mac, Linux)
// The idea here is to only send editor events for actual editor runs, not for things like -game runs of the editor.
const bool bIsEditorRun = WITH_EDITOR && GIsEditor && !IsRunningCommandlet();
// We also want to identify a real run of a game, which is NOT necessarily the opposite of an editor run.
// Ideally we'd be able to tell explicitly, but with content-only games, it becomes difficult.
// So we ensure we are not an editor run, we don't have EDITOR stuff compiled in, we are not running a commandlet,
// we are not a generic, utility program, and we require cooked data.
const bool bIsGameRun = !WITH_EDITOR && !IsRunningCommandlet() && !FPlatformProperties::IsProgram() && FPlatformProperties::RequiresCookedData();
const bool bShouldInitAnalytics = bIsEditorRun || bIsGameRun;
// Outside of the editor, the only engine analytics usage is the hardware survey
bShouldSendUsageEvents = bIsEditorRun
? GEngine->AreEditorAnalyticsEnabled()
: bIsGameRun
? GEngine->bHardwareSurveyEnabled
: false;
if (bShouldInitAnalytics)
{
{
// Setup some default engine analytics if there is nothing custom bound
FAnalytics::FProviderConfigurationDelegate DefaultEngineAnalyticsConfig;
DefaultEngineAnalyticsConfig.BindLambda(
[=]( const FString& KeyName, bool bIsValueRequired ) -> FString
{
static TMap<FString, FString> ConfigMap;
if (ConfigMap.Num() == 0)
{
ConfigMap.Add(TEXT("ProviderModuleName"), TEXT("AnalyticsET"));
ConfigMap.Add(TEXT("APIServerET"), TEXT("http://etsource.epicgames.com/ET2/"));
// We always use the "Release" analytics account unless we're running in analytics test mode (usually with
// a command-line parameter), or we're an internal Epic build
const FAnalytics::BuildType AnalyticsBuildType = FAnalytics::Get().GetBuildType();
const bool bUseReleaseAccount =
(AnalyticsBuildType == FAnalytics::Development || AnalyticsBuildType == FAnalytics::Release) &&
!FEngineBuildSettings::IsInternalBuild(); // Internal Epic build
const TCHAR* BuildTypeStr = bUseReleaseAccount ? TEXT("Release") : TEXT("Dev");
const TCHAR* UE4TypeStr = FRocketSupport::IsRocket() ? TEXT("Rocket") : FEngineBuildSettings::IsPerforceBuild() ? TEXT("Perforce") : TEXT("UnrealEngine");
if (bIsEditorRun)
{
ConfigMap.Add(TEXT("APIKeyET"), FString::Printf(TEXT("UEEditor.%s.%s"), UE4TypeStr, BuildTypeStr));
}
else
{
const UGeneralProjectSettings& ProjectSettings = *GetDefault<UGeneralProjectSettings>();
ConfigMap.Add(TEXT("APIKeyET"), FString::Printf(TEXT("UEGame.%s.%s|%s|%s"), UE4TypeStr, BuildTypeStr, *ProjectSettings.ProjectID.ToString(), *ProjectSettings.ProjectName));
}
}
// Check for overrides
if( GetEngineAnalyticsOverrideConfigDelegate().IsBound() )
{
const FString OverrideValue = GetEngineAnalyticsOverrideConfigDelegate().Execute( KeyName, bIsValueRequired );
if( !OverrideValue.IsEmpty() )
{
return OverrideValue;
}
}
FString* ConfigValue = ConfigMap.Find(KeyName);
return ConfigValue != NULL ? *ConfigValue : TEXT("");
} );
// Connect the engine analytics provider (if there is a configuration delegate installed)
Analytics = FAnalytics::Get().CreateAnalyticsProvider(
FName(*DefaultEngineAnalyticsConfig.Execute(TEXT("ProviderModuleName"), true)),
DefaultEngineAnalyticsConfig);
if (Analytics.IsValid())
{
Analytics->SetUserID(FString::Printf(TEXT("%s|%s|%s"), *FPlatformMisc::GetMachineId().ToString(EGuidFormats::Digits).ToLower(), *FPlatformMisc::GetEpicAccountId(), *FPlatformMisc::GetOperatingSystemId()));
TArray<FAnalyticsEventAttribute> StartSessionAttributes;
GEngine->CreateStartupAnalyticsAttributes( StartSessionAttributes );
// Add project info whether we are in editor or game.
const UGeneralProjectSettings& ProjectSettings = *GetDefault<UGeneralProjectSettings>();
StartSessionAttributes.Emplace(TEXT("ProjectName"), ProjectSettings.ProjectName);
StartSessionAttributes.Emplace(TEXT("ProjectID"), ProjectSettings.ProjectID);
StartSessionAttributes.Emplace(TEXT("ProjectDescription"), ProjectSettings.Description);
StartSessionAttributes.Emplace(TEXT("ProjectVersion"), ProjectSettings.ProjectVersion);
Analytics->StartSession( StartSessionAttributes );
}
}
}
bIsInitialized = true;
}
void FAssetTypeActions_SoundCue::ExecuteConsolidateAttenuation(TArray<TWeakObjectPtr<USoundCue>> Objects)
{
TMap<FAttenuationSettings*,TArray<USoundCue*>> UnmatchedAttenuations;
for (auto ObjIt = Objects.CreateConstIterator(); ObjIt; ++ObjIt)
{
USoundCue* SoundCue = (*ObjIt).Get();
bool bFound = false;
if ( SoundCue && SoundCue->bOverrideAttenuation )
{
for (auto UnmatchedIt = UnmatchedAttenuations.CreateIterator(); UnmatchedIt; ++UnmatchedIt)
{
// Found attenuation settings to consolidate together
if (SoundCue->AttenuationOverrides == *UnmatchedIt.Key())
{
UnmatchedIt.Value().Add(SoundCue);
bFound = true;
break;
}
}
if (!bFound)
{
UnmatchedAttenuations.FindOrAdd(&SoundCue->AttenuationOverrides).Add(SoundCue);
}
}
}
if (UnmatchedAttenuations.Num() > 0)
{
FString DefaultSuffix;
TArray<UObject*> ObjectsToSync;
FAssetToolsModule& AssetToolsModule = FModuleManager::GetModuleChecked<FAssetToolsModule>("AssetTools");
USoundAttenuationFactory* Factory = ConstructObject<USoundAttenuationFactory>(USoundAttenuationFactory::StaticClass());
for (auto UnmatchedIt = UnmatchedAttenuations.CreateConstIterator(); UnmatchedIt; ++UnmatchedIt)
{
if (UnmatchedIt.Value().Num() > 1)
{
FString Name;
FString PackageName;
CreateUniqueAssetName("/Game/Sounds/SoundAttenuations/SharedAttenuation", DefaultSuffix, PackageName, Name);
USoundAttenuation* SoundAttenuation = Cast<USoundAttenuation>(AssetToolsModule.Get().CreateAsset(Name, FPackageName::GetLongPackagePath(PackageName), USoundAttenuation::StaticClass(), Factory));
if (SoundAttenuation)
{
SoundAttenuation->Attenuation = *UnmatchedIt.Key();
for (int32 SoundCueIndex = 0; SoundCueIndex < UnmatchedIt.Value().Num(); ++SoundCueIndex)
{
USoundCue* SoundCue = UnmatchedIt.Value()[SoundCueIndex];
SoundCue->bOverrideAttenuation = false;
SoundCue->AttenuationSettings = SoundAttenuation;
SoundCue->MarkPackageDirty();
}
}
}
}
if ( ObjectsToSync.Num() > 0 )
{
FAssetTools::Get().SyncBrowserToAssets(ObjectsToSync);
}
}
}
void AActor::RerunConstructionScripts()
{
checkf(!HasAnyFlags(RF_ClassDefaultObject), TEXT("RerunConstructionScripts should never be called on a CDO as it can mutate the transient data on the CDO which then propagates to instances!"));
FEditorScriptExecutionGuard ScriptGuard;
// don't allow (re)running construction scripts on dying actors
bool bAllowReconstruction = !IsPendingKill() && !HasAnyFlags(RF_BeginDestroyed|RF_FinishDestroyed);
#if WITH_EDITOR
if(bAllowReconstruction && GIsEditor)
{
// Generate the blueprint hierarchy for this actor
TArray<UBlueprint*> ParentBPStack;
bAllowReconstruction = UBlueprint::GetBlueprintHierarchyFromClass(GetClass(), ParentBPStack);
if(bAllowReconstruction)
{
for(int i = ParentBPStack.Num() - 1; i > 0 && bAllowReconstruction; --i)
{
const UBlueprint* ParentBP = ParentBPStack[i];
if(ParentBP && ParentBP->bBeingCompiled)
{
// don't allow (re)running construction scripts if a parent BP is being compiled
bAllowReconstruction = false;
}
}
}
}
#endif
if(bAllowReconstruction)
{
// Set global flag to let system know we are reconstructing blueprint instances
TGuardValue<bool> GuardTemplateNameFlag(GIsReconstructingBlueprintInstances, true);
// Temporarily suspend the undo buffer; we don't need to record reconstructed component objects into the current transaction
ITransaction* CurrentTransaction = GUndo;
GUndo = NULL;
// Create cache to store component data across rerunning construction scripts
#if WITH_EDITOR
FActorTransactionAnnotation* ActorTransactionAnnotation = CurrentTransactionAnnotation.Get();
#endif
FComponentInstanceDataCache* InstanceDataCache;
FTransform OldTransform = FTransform::Identity;
FName SocketName;
AActor* Parent = NULL;
USceneComponent* ParentComponent = NULL;
bool bUseRootComponentProperties = true;
// Struct to store info about attached actors
struct FAttachedActorInfo
{
AActor* AttachedActor;
FName AttachedToSocket;
bool bSetRelativeTransform;
FTransform RelativeTransform;
};
// Save info about attached actors
TArray<FAttachedActorInfo> AttachedActorInfos;
#if WITH_EDITOR
if (ActorTransactionAnnotation)
{
InstanceDataCache = &ActorTransactionAnnotation->ComponentInstanceData;
if (ActorTransactionAnnotation->bRootComponentDataCached)
{
OldTransform = ActorTransactionAnnotation->RootComponentData.Transform;
Parent = ActorTransactionAnnotation->RootComponentData.AttachedParentInfo.Actor.Get();
if (Parent)
{
USceneComponent* AttachParent = ActorTransactionAnnotation->RootComponentData.AttachedParentInfo.AttachParent.Get();
ParentComponent = (AttachParent ? AttachParent : FindObjectFast<USceneComponent>(Parent, ActorTransactionAnnotation->RootComponentData.AttachedParentInfo.AttachParentName));
SocketName = ActorTransactionAnnotation->RootComponentData.AttachedParentInfo.SocketName;
DetachRootComponentFromParent();
}
for (const auto& CachedAttachInfo : ActorTransactionAnnotation->RootComponentData.AttachedToInfo)
{
AActor* AttachedActor = CachedAttachInfo.Actor.Get();
if (AttachedActor)
{
FAttachedActorInfo Info;
Info.AttachedActor = AttachedActor;
Info.AttachedToSocket = CachedAttachInfo.SocketName;
Info.bSetRelativeTransform = true;
Info.RelativeTransform = CachedAttachInfo.RelativeTransform;
AttachedActorInfos.Add(Info);
AttachedActor->DetachRootComponentFromParent();
}
}
bUseRootComponentProperties = false;
}
}
else
#endif
{
InstanceDataCache = new FComponentInstanceDataCache(this);
// If there are attached objects detach them and store the socket names
TArray<AActor*> AttachedActors;
GetAttachedActors(AttachedActors);
for (AActor* AttachedActor : AttachedActors)
{
USceneComponent* EachRoot = AttachedActor->GetRootComponent();
// If the component we are attached to is about to go away...
if (EachRoot && EachRoot->AttachParent && EachRoot->AttachParent->IsCreatedByConstructionScript())
{
// Save info about actor to reattach
FAttachedActorInfo Info;
Info.AttachedActor = AttachedActor;
Info.AttachedToSocket = EachRoot->AttachSocketName;
Info.bSetRelativeTransform = false;
AttachedActorInfos.Add(Info);
// Now detach it
AttachedActor->Modify();
EachRoot->DetachFromParent(true);
}
}
}
if (bUseRootComponentProperties && RootComponent != nullptr)
{
// Do not need to detach if root component is not going away
if (RootComponent->AttachParent != NULL && RootComponent->IsCreatedByConstructionScript())
{
Parent = RootComponent->AttachParent->GetOwner();
// Root component should never be attached to another component in the same actor!
if (Parent == this)
{
UE_LOG(LogActor, Warning, TEXT("RerunConstructionScripts: RootComponent (%s) attached to another component in this Actor (%s)."), *RootComponent->GetPathName(), *Parent->GetPathName());
Parent = NULL;
}
ParentComponent = RootComponent->AttachParent;
SocketName = RootComponent->AttachSocketName;
//detach it to remove any scaling
RootComponent->DetachFromParent(true);
}
OldTransform = RootComponent->ComponentToWorld;
OldTransform.SetTranslation(RootComponent->GetComponentLocation()); // take into account any custom location
}
#if WITH_EDITOR
// Save the current construction script-created components by name
TMap<const FName, UObject*> DestroyedComponentsByName;
TInlineComponentArray<UActorComponent*> PreviouslyAttachedComponents;
GetComponents(PreviouslyAttachedComponents);
for (auto Component : PreviouslyAttachedComponents)
{
if (Component)
{
if (Component->IsCreatedByConstructionScript())
{
DestroyedComponentsByName.Add(Component->GetFName(), Component);
}
else
{
UActorComponent* OuterComponent = Component->GetTypedOuter<UActorComponent>();
while (OuterComponent)
{
if (OuterComponent->IsCreatedByConstructionScript())
{
DestroyedComponentsByName.Add(Component->GetFName(), Component);
break;
}
OuterComponent = OuterComponent->GetTypedOuter<UActorComponent>();
}
}
}
}
#endif
// Destroy existing components
DestroyConstructedComponents();
// Reset random streams
ResetPropertiesForConstruction();
// Exchange net roles before running construction scripts
UWorld *OwningWorld = GetWorld();
if (OwningWorld && !OwningWorld->IsServer())
{
ExchangeNetRoles(true);
}
// Run the construction scripts
ExecuteConstruction(OldTransform, InstanceDataCache);
if(Parent)
{
USceneComponent* ChildRoot = GetRootComponent();
if (ParentComponent == NULL)
{
ParentComponent = Parent->GetRootComponent();
}
if (ChildRoot != NULL && ParentComponent != NULL)
{
ChildRoot->AttachTo(ParentComponent, SocketName, EAttachLocation::KeepWorldPosition);
}
}
// If we had attached children reattach them now - unless they are already attached
for(FAttachedActorInfo& Info : AttachedActorInfos)
{
// If this actor is no longer attached to anything, reattach
if (!Info.AttachedActor->IsPendingKill() && Info.AttachedActor->GetAttachParentActor() == NULL)
{
USceneComponent* ChildRoot = Info.AttachedActor->GetRootComponent();
if (ChildRoot && ChildRoot->AttachParent != RootComponent)
{
ChildRoot->AttachTo(RootComponent, Info.AttachedToSocket, EAttachLocation::KeepWorldPosition);
if (Info.bSetRelativeTransform)
{
ChildRoot->SetRelativeTransform(Info.RelativeTransform);
}
ChildRoot->UpdateComponentToWorld();
}
}
}
// Restore the undo buffer
GUndo = CurrentTransaction;
#if WITH_EDITOR
// Create the mapping of old->new components and notify the editor of the replacements
TMap<UObject*, UObject*> OldToNewComponentMapping;
TInlineComponentArray<UActorComponent*> NewComponents;
GetComponents(NewComponents);
for (auto NewComp : NewComponents)
{
const FName NewCompName = NewComp->GetFName();
if (DestroyedComponentsByName.Contains(NewCompName))
{
OldToNewComponentMapping.Add(DestroyedComponentsByName[NewCompName], NewComp);
}
}
if (GEditor && (OldToNewComponentMapping.Num() > 0))
{
GEditor->NotifyToolsOfObjectReplacement(OldToNewComponentMapping);
}
if (ActorTransactionAnnotation)
{
CurrentTransactionAnnotation = NULL;
}
else
#endif
{
delete InstanceDataCache;
}
}
}
void FCrashReportAnalytics::Initialize()
{
checkf(!bIsInitialized, TEXT("FCrashReportAnalytics::Initialize called more than once."));
// Never use analytics when running a commandlet tool
const bool bShouldInitAnalytics = !IsRunningCommandlet();
if( bShouldInitAnalytics )
{
// Setup some default engine analytics if there is nothing custom bound
FAnalytics::FProviderConfigurationDelegate DefaultEngineAnalyticsConfig;
DefaultEngineAnalyticsConfig.BindStatic(
[]( const FString& KeyName, bool bIsValueRequired ) -> FString
{
static TMap<FString, FString> ConfigMap;
if( ConfigMap.Num() == 0 )
{
ConfigMap.Add( TEXT( "ProviderModuleName" ), TEXT( "AnalyticsET" ) );
ConfigMap.Add( TEXT( "APIServerET" ), TEXT( "http://etsource.epicgames.com/ET2/" ) );
// We always use the "Release" analytics account unless we're running in analytics test mode (usually with
// a command-line parameter), or we're an internal Epic build
bool bUseReleaseAccount =
(FAnalytics::Get().GetBuildType() == FAnalytics::Development ||
FAnalytics::Get().GetBuildType() == FAnalytics::Release) &&
!FEngineBuildSettings::IsInternalBuild(); // Internal Epic build
if( FRocketSupport::IsRocket() )
{
const TCHAR* DevelopmentAccountAPIKeyET = TEXT( "Rocket.Dev" );
const TCHAR* ReleaseAccountAPIKeyET = TEXT( "Rocket.Release" );
ConfigMap.Add( TEXT( "APIKeyET" ), bUseReleaseAccount ? ReleaseAccountAPIKeyET : DevelopmentAccountAPIKeyET );
}
else if( FEngineBuildSettings::IsPerforceBuild() )
{
const TCHAR* DevelopmentAccountAPIKeyET = TEXT( "Perforce.Dev" );
const TCHAR* ReleaseAccountAPIKeyET = TEXT( "Perforce.Release" );
ConfigMap.Add( TEXT( "APIKeyET" ), bUseReleaseAccount ? ReleaseAccountAPIKeyET : DevelopmentAccountAPIKeyET );
}
else
{
const TCHAR* DevelopmentAccountAPIKeyET = TEXT( "UnrealEngine.Dev" );
const TCHAR* ReleaseAccountAPIKeyET = TEXT( "UnrealEngine.Release" );
ConfigMap.Add( TEXT( "APIKeyET" ), bUseReleaseAccount ? ReleaseAccountAPIKeyET : DevelopmentAccountAPIKeyET );
}
}
// Check for overrides
if( GetCrashReportAnalyticsOverrideConfigDelegate().IsBound() )
{
const FString OverrideValue = GetCrashReportAnalyticsOverrideConfigDelegate().Execute( KeyName, bIsValueRequired );
if( !OverrideValue.IsEmpty() )
{
return OverrideValue;
}
}
FString* ConfigValue = ConfigMap.Find( KeyName );
return ConfigValue != NULL ? *ConfigValue : TEXT( "" );
} );
// Connect the engine analytics provider (if there is a configuration delegate installed)
Analytics = FAnalytics::Get().CreateAnalyticsProvider(
FName( *DefaultEngineAnalyticsConfig.Execute( TEXT( "ProviderModuleName" ), true ) ),
DefaultEngineAnalyticsConfig );
if( Analytics.IsValid() )
{
//const FString MachineId = FPlatformMisc::GetMachineId().ToString( EGuidFormats::Digits );
//Analytics->SetUserID( MachineId );
Analytics->SetUserID(FPlatformMisc::GetUniqueDeviceId());
Analytics->StartSession();
}
}
bIsInitialized = true;
}
void UOffAxisGameViewportClient::Draw(FViewport* InViewport, FCanvas* SceneCanvas)
{
//Valid SceneCanvas is required. Make this explicit.
check(SceneCanvas);
FCanvas* DebugCanvas = InViewport->GetDebugCanvas();
// Create a temporary canvas if there isn't already one.
static FName CanvasObjectName(TEXT("CanvasObject"));
UCanvas* CanvasObject = GetCanvasByName(CanvasObjectName);
CanvasObject->Canvas = SceneCanvas;
// Create temp debug canvas object
static FName DebugCanvasObjectName(TEXT("DebugCanvasObject"));
UCanvas* DebugCanvasObject = GetCanvasByName(DebugCanvasObjectName);
DebugCanvasObject->Canvas = DebugCanvas;
DebugCanvasObject->Init(InViewport->GetSizeXY().X, InViewport->GetSizeXY().Y, NULL);
const bool bScaledToRenderTarget = GEngine->HMDDevice.IsValid() && GEngine->IsStereoscopic3D(InViewport);
if (bScaledToRenderTarget)
{
// Allow HMD to modify screen settings
GEngine->HMDDevice->UpdateScreenSettings(Viewport);
}
if (DebugCanvas)
{
DebugCanvas->SetScaledToRenderTarget(bScaledToRenderTarget);
}
if (SceneCanvas)
{
SceneCanvas->SetScaledToRenderTarget(bScaledToRenderTarget);
}
bool bUIDisableWorldRendering = false;
FViewElementDrawer GameViewDrawer;
// create the view family for rendering the world scene to the viewport's render target
FSceneViewFamilyContext ViewFamily(FSceneViewFamily::ConstructionValues(
InViewport,
GetWorld()->Scene,
EngineShowFlags)
.SetRealtimeUpdate(true));
// Allow HMD to modify the view later, just before rendering
if (GEngine->HMDDevice.IsValid() && GEngine->IsStereoscopic3D(InViewport))
{
ISceneViewExtension* HmdViewExt = GEngine->HMDDevice->GetViewExtension();
if (HmdViewExt)
{
ViewFamily.ViewExtensions.Add(HmdViewExt);
HmdViewExt->ModifyShowFlags(ViewFamily.EngineShowFlags);
}
}
ESplitScreenType::Type SplitScreenConfig = GetCurrentSplitscreenConfiguration();
EngineShowFlagOverride(ESFIM_Game, (EViewModeIndex)ViewModeIndex, ViewFamily.EngineShowFlags, NAME_None, SplitScreenConfig != ESplitScreenType::None);
TMap<ULocalPlayer*, FSceneView*> PlayerViewMap;
FAudioDevice* AudioDevice = GEngine->GetAudioDevice();
bool bReverbSettingsFound = false;
FReverbSettings ReverbSettings;
class AAudioVolume* AudioVolume = nullptr;
for (FConstPlayerControllerIterator Iterator = GetWorld()->GetPlayerControllerIterator(); Iterator; ++Iterator)
{
APlayerController* PlayerController = *Iterator;
if (PlayerController)
{
ULocalPlayer* LocalPlayer = Cast<ULocalPlayer>(PlayerController->Player);
if (LocalPlayer)
{
const bool bEnableStereo = GEngine->IsStereoscopic3D(InViewport);
int32 NumViews = bEnableStereo ? 2 : 1;
for (int i = 0; i < NumViews; ++i)
{
// Calculate the player's view information.
FVector ViewLocation;
FRotator ViewRotation;
EStereoscopicPass PassType = !bEnableStereo ? eSSP_FULL : ((i == 0) ? eSSP_LEFT_EYE : eSSP_RIGHT_EYE);
FSceneView* View = LocalPlayer->CalcSceneView(&ViewFamily, ViewLocation, ViewRotation, InViewport, &GameViewDrawer, PassType);
if (mOffAxisMatrixSetted)
UpdateProjectionMatrix(View, mOffAxisMatrix);
if (View)
{
if (View->Family->EngineShowFlags.Wireframe)
{
// Wireframe color is emissive-only, and mesh-modifying materials do not use material substitution, hence...
View->DiffuseOverrideParameter = FVector4(0.f, 0.f, 0.f, 0.f);
View->SpecularOverrideParameter = FVector4(0.f, 0.f, 0.f, 0.f);
}
else if (View->Family->EngineShowFlags.OverrideDiffuseAndSpecular)
{
View->DiffuseOverrideParameter = FVector4(GEngine->LightingOnlyBrightness.R, GEngine->LightingOnlyBrightness.G, GEngine->LightingOnlyBrightness.B, 0.0f);
View->SpecularOverrideParameter = FVector4(.1f, .1f, .1f, 0.0f);
}
else if (View->Family->EngineShowFlags.ReflectionOverride)
{
View->DiffuseOverrideParameter = FVector4(0.f, 0.f, 0.f, 0.f);
View->SpecularOverrideParameter = FVector4(1, 1, 1, 0.0f);
View->NormalOverrideParameter = FVector4(0, 0, 1, 0.0f);
View->RoughnessOverrideParameter = FVector2D(0.0f, 0.0f);
}
if (!View->Family->EngineShowFlags.Diffuse)
{
View->DiffuseOverrideParameter = FVector4(0.f, 0.f, 0.f, 0.f);
}
if (!View->Family->EngineShowFlags.Specular)
{
View->SpecularOverrideParameter = FVector4(0.f, 0.f, 0.f, 0.f);
}
View->CameraConstrainedViewRect = View->UnscaledViewRect;
// If this is the primary drawing pass, update things that depend on the view location
if (i == 0)
{
// Save the location of the view.
LocalPlayer->LastViewLocation = ViewLocation;
PlayerViewMap.Add(LocalPlayer, View);
// Update the listener.
if (AudioDevice != NULL)
{
FVector Location;
FVector ProjFront;
FVector ProjRight;
PlayerController->GetAudioListenerPosition(/*out*/ Location, /*out*/ ProjFront, /*out*/ ProjRight);
FTransform ListenerTransform(FRotationMatrix::MakeFromXY(ProjFront, ProjRight));
ListenerTransform.SetTranslation(Location);
ListenerTransform.NormalizeRotation();
bReverbSettingsFound = true;
FReverbSettings PlayerReverbSettings;
FInteriorSettings PlayerInteriorSettings;
class AAudioVolume* PlayerAudioVolume = GetWorld()->GetAudioSettings(Location, &PlayerReverbSettings, &PlayerInteriorSettings);
if (AudioVolume == nullptr || (PlayerAudioVolume != nullptr && PlayerAudioVolume->Priority > AudioVolume->Priority))
{
AudioVolume = PlayerAudioVolume;
ReverbSettings = PlayerReverbSettings;
}
uint32 ViewportIndex = PlayerViewMap.Num() - 1;
AudioDevice->SetListener(ViewportIndex, ListenerTransform, (View->bCameraCut ? 0.f : GetWorld()->GetDeltaSeconds()), PlayerAudioVolume, PlayerInteriorSettings);
}
}
// Add view information for resource streaming.
IStreamingManager::Get().AddViewInformation(View->ViewMatrices.ViewOrigin, View->ViewRect.Width(), View->ViewRect.Width() * View->ViewMatrices.ProjMatrix.M[0][0]);
GetWorld()->ViewLocationsRenderedLastFrame.Add(View->ViewMatrices.ViewOrigin);
}
}
}
}
}
if (bReverbSettingsFound)
{
AudioDevice->SetReverbSettings(AudioVolume, ReverbSettings);
}
// Update level streaming.
GetWorld()->UpdateLevelStreaming();
// Draw the player views.
if (!bDisableWorldRendering && !bUIDisableWorldRendering && PlayerViewMap.Num() > 0)
{
GetRendererModule().BeginRenderingViewFamily(SceneCanvas, &ViewFamily);
}
// Clear areas of the rendertarget (backbuffer) that aren't drawn over by the views.
{
// Find largest rectangle bounded by all rendered views.
uint32 MinX = InViewport->GetSizeXY().X, MinY = InViewport->GetSizeXY().Y, MaxX = 0, MaxY = 0;
uint32 TotalArea = 0;
for (int32 ViewIndex = 0; ViewIndex < ViewFamily.Views.Num(); ++ViewIndex)
{
const FSceneView* View = ViewFamily.Views[ViewIndex];
FIntRect UpscaledViewRect = View->UnscaledViewRect;
MinX = FMath::Min<uint32>(UpscaledViewRect.Min.X, MinX);
MinY = FMath::Min<uint32>(UpscaledViewRect.Min.Y, MinY);
MaxX = FMath::Max<uint32>(UpscaledViewRect.Max.X, MaxX);
MaxY = FMath::Max<uint32>(UpscaledViewRect.Max.Y, MaxY);
TotalArea += FMath::TruncToInt(UpscaledViewRect.Width()) * FMath::TruncToInt(UpscaledViewRect.Height());
}
// To draw black borders around the rendered image (prevents artifacts from post processing passes that read outside of the image e.g. PostProcessAA)
{
int32 BlackBorders = 0; // FMath::Clamp(CVarSetBlackBordersEnabled.GetValueOnGameThread(), 0, 10);
if (ViewFamily.Views.Num() == 1 && BlackBorders)
{
MinX += BlackBorders;
MinY += BlackBorders;
MaxX -= BlackBorders;
MaxY -= BlackBorders;
TotalArea = (MaxX - MinX) * (MaxY - MinY);
}
}
// If the views don't cover the entire bounding rectangle, clear the entire buffer.
if (ViewFamily.Views.Num() == 0 || TotalArea != (MaxX - MinX)*(MaxY - MinY) || bDisableWorldRendering)
{
SceneCanvas->DrawTile(0, 0, InViewport->GetSizeXY().X, InViewport->GetSizeXY().Y, 0.0f, 0.0f, 1.0f, 1.f, FLinearColor::Black, NULL, false);
}
else
{
// clear left
if (MinX > 0)
{
SceneCanvas->DrawTile(0, 0, MinX, InViewport->GetSizeXY().Y, 0.0f, 0.0f, 1.0f, 1.f, FLinearColor::Black, NULL, false);
}
// clear right
if (MaxX < (uint32)InViewport->GetSizeXY().X)
{
SceneCanvas->DrawTile(MaxX, 0, InViewport->GetSizeXY().X, InViewport->GetSizeXY().Y, 0.0f, 0.0f, 1.0f, 1.f, FLinearColor::Black, NULL, false);
}
// clear top
if (MinY > 0)
{
SceneCanvas->DrawTile(MinX, 0, MaxX, MinY, 0.0f, 0.0f, 1.0f, 1.f, FLinearColor::Black, NULL, false);
}
// clear bottom
if (MaxY < (uint32)InViewport->GetSizeXY().Y)
{
SceneCanvas->DrawTile(MinX, MaxY, MaxX, InViewport->GetSizeXY().Y, 0.0f, 0.0f, 1.0f, 1.f, FLinearColor::Black, NULL, false);
}
}
}
// Remove temporary debug lines.
if (GetWorld()->LineBatcher != NULL)
{
GetWorld()->LineBatcher->Flush();
}
if (GetWorld()->ForegroundLineBatcher != NULL)
{
GetWorld()->ForegroundLineBatcher->Flush();
}
// Draw FX debug information.
if (GetWorld()->FXSystem)
{
GetWorld()->FXSystem->DrawDebug(SceneCanvas);
}
// Render the UI.
{
//SCOPE_CYCLE_COUNTER(STAT_UIDrawingTime);
// render HUD
bool bDisplayedSubtitles = false;
for (FConstPlayerControllerIterator Iterator = GetWorld()->GetPlayerControllerIterator(); Iterator; ++Iterator)
{
APlayerController* PlayerController = *Iterator;
if (PlayerController)
{
ULocalPlayer* LocalPlayer = Cast<ULocalPlayer>(PlayerController->Player);
if (LocalPlayer)
{
FSceneView* View = PlayerViewMap.FindRef(LocalPlayer);
if (View != NULL)
{
// rendering to directly to viewport target
FVector CanvasOrigin(FMath::TruncToFloat(View->UnscaledViewRect.Min.X), FMath::TruncToInt(View->UnscaledViewRect.Min.Y), 0.f);
CanvasObject->Init(View->UnscaledViewRect.Width(), View->UnscaledViewRect.Height(), View);
// Set the canvas transform for the player's view rectangle.
SceneCanvas->PushAbsoluteTransform(FTranslationMatrix(CanvasOrigin));
CanvasObject->ApplySafeZoneTransform();
// Render the player's HUD.
if (PlayerController->MyHUD)
{
//SCOPE_CYCLE_COUNTER(STAT_HudTime);
DebugCanvasObject->SceneView = View;
PlayerController->MyHUD->SetCanvas(CanvasObject, DebugCanvasObject);
if (GEngine->IsStereoscopic3D(InViewport))
{
check(GEngine->StereoRenderingDevice.IsValid());
GEngine->StereoRenderingDevice->PushViewportCanvas(eSSP_LEFT_EYE, SceneCanvas, CanvasObject, Viewport);
PlayerController->MyHUD->PostRender();
SceneCanvas->PopTransform();
GEngine->StereoRenderingDevice->PushViewportCanvas(eSSP_RIGHT_EYE, SceneCanvas, CanvasObject, Viewport);
PlayerController->MyHUD->PostRender();
SceneCanvas->PopTransform();
// Reset the canvas for rendering to the full viewport.
CanvasObject->Reset();
CanvasObject->SizeX = View->UnscaledViewRect.Width();
CanvasObject->SizeY = View->UnscaledViewRect.Height();
CanvasObject->SetView(NULL);
CanvasObject->Update();
}
else
{
PlayerController->MyHUD->PostRender();
}
// Put these pointers back as if a blueprint breakpoint hits during HUD PostRender they can
// have been changed
CanvasObject->Canvas = SceneCanvas;
DebugCanvasObject->Canvas = DebugCanvas;
// A side effect of PostRender is that the playercontroller could be destroyed
if (!PlayerController->IsPendingKill())
{
PlayerController->MyHUD->SetCanvas(NULL, NULL);
}
}
if (DebugCanvas != NULL)
{
DebugCanvas->PushAbsoluteTransform(FTranslationMatrix(CanvasOrigin));
UDebugDrawService::Draw(ViewFamily.EngineShowFlags, InViewport, View, DebugCanvas);
DebugCanvas->PopTransform();
}
CanvasObject->PopSafeZoneTransform();
SceneCanvas->PopTransform();
// draw subtitles
if (!bDisplayedSubtitles)
{
FVector2D MinPos(0.f, 0.f);
FVector2D MaxPos(1.f, 1.f);
GetSubtitleRegion(MinPos, MaxPos);
uint32 SizeX = SceneCanvas->GetRenderTarget()->GetSizeXY().X;
uint32 SizeY = SceneCanvas->GetRenderTarget()->GetSizeXY().Y;
FIntRect SubtitleRegion(FMath::TruncToInt(SizeX * MinPos.X), FMath::TruncToInt(SizeY * MinPos.Y), FMath::TruncToInt(SizeX * MaxPos.X), FMath::TruncToInt(SizeY * MaxPos.Y));
// We need a world to do this
FSubtitleManager::GetSubtitleManager()->DisplaySubtitles(SceneCanvas, SubtitleRegion, GetWorld()->GetAudioTimeSeconds());
}
}
}
}
}
//ensure canvas has been flushed before rendering UI
SceneCanvas->Flush_GameThread();
if (DebugCanvas != NULL)
{
DebugCanvas->Flush_GameThread();
}
// Allow the viewport to render additional stuff
PostRender(DebugCanvasObject);
// Render the console.
if (ViewportConsole)
{
if (GEngine->IsStereoscopic3D(InViewport))
{
GEngine->StereoRenderingDevice->PushViewportCanvas(eSSP_LEFT_EYE, DebugCanvas, DebugCanvasObject, Viewport);
ViewportConsole->PostRender_Console(DebugCanvasObject);
#if !UE_BUILD_SHIPPING
if (DebugCanvas != NULL && GEngine->HMDDevice.IsValid())
{
GEngine->HMDDevice->DrawDebug(DebugCanvasObject, eSSP_LEFT_EYE);
}
#endif
DebugCanvas->PopTransform();
GEngine->StereoRenderingDevice->PushViewportCanvas(eSSP_RIGHT_EYE, DebugCanvas, DebugCanvasObject, Viewport);
ViewportConsole->PostRender_Console(DebugCanvasObject);
#if !UE_BUILD_SHIPPING
if (DebugCanvas != NULL && GEngine->HMDDevice.IsValid())
{
GEngine->HMDDevice->DrawDebug(DebugCanvasObject, eSSP_RIGHT_EYE);
}
#endif
DebugCanvas->PopTransform();
// Reset the canvas for rendering to the full viewport.
DebugCanvasObject->Reset();
DebugCanvasObject->SizeX = Viewport->GetSizeXY().X;
DebugCanvasObject->SizeY = Viewport->GetSizeXY().Y;
DebugCanvasObject->SetView(NULL);
DebugCanvasObject->Update();
}
else
{
ViewportConsole->PostRender_Console(DebugCanvasObject);
}
}
}
// Grab the player camera location and orientation so we can pass that along to the stats drawing code.
FVector PlayerCameraLocation = FVector::ZeroVector;
FRotator PlayerCameraRotation = FRotator::ZeroRotator;
{
for (FConstPlayerControllerIterator Iterator = GetWorld()->GetPlayerControllerIterator(); Iterator; ++Iterator)
{
(*Iterator)->GetPlayerViewPoint(PlayerCameraLocation, PlayerCameraRotation);
}
}
if (GEngine->IsStereoscopic3D(InViewport))
{
GEngine->StereoRenderingDevice->PushViewportCanvas(eSSP_LEFT_EYE, DebugCanvas, DebugCanvasObject, InViewport);
DrawStatsHUD(GetWorld(), InViewport, DebugCanvas, DebugCanvasObject, DebugProperties, PlayerCameraLocation, PlayerCameraRotation);
DebugCanvas->PopTransform();
GEngine->StereoRenderingDevice->PushViewportCanvas(eSSP_RIGHT_EYE, DebugCanvas, DebugCanvasObject, InViewport);
DrawStatsHUD(GetWorld(), InViewport, DebugCanvas, DebugCanvasObject, DebugProperties, PlayerCameraLocation, PlayerCameraRotation);
DebugCanvas->PopTransform();
// Reset the canvas for rendering to the full viewport.
DebugCanvasObject->Reset();
DebugCanvasObject->SizeX = Viewport->GetSizeXY().X;
DebugCanvasObject->SizeY = Viewport->GetSizeXY().Y;
DebugCanvasObject->SetView(NULL);
DebugCanvasObject->Update();
#if !UE_BUILD_SHIPPING
if (GEngine->HMDDevice.IsValid())
{
GEngine->HMDDevice->DrawDebug(DebugCanvasObject, eSSP_FULL);
}
#endif
}
else
{
DrawStatsHUD(GetWorld(), InViewport, DebugCanvas, DebugCanvasObject, DebugProperties, PlayerCameraLocation, PlayerCameraRotation);
}
}