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