void FGameLiveStreaming::StopBroadcastingGame()
{
if( bIsBroadcasting )
{
if( LiveStreamer != nullptr )
{
if( LiveStreamer->IsBroadcasting() )
{
LiveStreamer->StopWebCam();
LiveStreamer->StopBroadcasting();
}
}
if( FSlateApplication::IsInitialized() ) // During shutdown, Slate may have already been destroyed by the time our viewport gets cleaned up
{
FSlateRenderer* SlateRenderer = FSlateApplication::Get().GetRenderer().Get();
SlateRenderer->OnSlateWindowRendered().RemoveAll( this );
}
// Cleanup readback buffer textures
{
FlushRenderingCommands();
ReadbackTextures[0].SafeRelease();
ReadbackTextures[1].SafeRelease();
ReadbackTextureIndex = 0;
ReadbackBuffers[0] = nullptr;
ReadbackBuffers[1] = nullptr;
ReadbackBufferIndex = 0;
}
}
}
void UMediaTexture::PreEditChange( UProperty* PropertyAboutToChange )
{
// this will release the FMediaTextureResource
Super::PreEditChange(PropertyAboutToChange);
FlushRenderingCommands();
}
void UStaticMeshComponent::InvalidateLightingCacheDetailed(bool bInvalidateBuildEnqueuedLighting, bool bTranslationOnly)
{
if(bHasCachedStaticLighting)
{
// Save the static mesh state for transactions, force it to be marked dirty if we are going to discard any static lighting data.
Modify(true);
// Detach the component from the scene for the duration of this function.
FComponentReregisterContext ReregisterContext(this);
// Block until the RT processes the unregister before modifying variables that it may need to access
FlushRenderingCommands();
Super::InvalidateLightingCacheDetailed(bInvalidateBuildEnqueuedLighting, bTranslationOnly);
// Discard all cached lighting.
check(AttachmentCounter.GetValue() == 0);
IrrelevantLights.Empty();
for(int32 i = 0; i < LODData.Num(); i++)
{
FStaticMeshComponentLODInfo& LODDataElement = LODData[i];
LODDataElement.LightMap = NULL;
LODDataElement.ShadowMap = NULL;
}
}
if (bInvalidateBuildEnqueuedLighting)
{
bStaticLightingBuildEnqueued = false;
}
}
FGlobalComponentReregisterContext::FGlobalComponentReregisterContext(const TArray<AActor*>& InParentActors)
{
ActiveGlobalReregisterContextCount++;
// wait until resources are released
FlushRenderingCommands();
}
/**
* Exec handler implementation.
*
* @param InWorld World context
* @param Cmd Command to parse
* @param Ar Output device to log to
*
* @return true if command was handled, false otherwise
*/
bool FSystemSettings::Exec( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar )
{
FSystemSettingsData OldSystemSettings = *this;
// Keep track whether the command was handled or not.
bool bHandledCommand = false;
if( FParse::Command(&Cmd,TEXT("SCALE")) )
{
// Some of these settings are used in both threads so we need to stop the rendering thread before changing them.
FlushRenderingCommands();
if( FParse::Command(&Cmd,TEXT("LOWEND")) )
{
bHandledCommand = HandleLowendCommand( Cmd, Ar );
}
else if( FParse::Command(&Cmd,TEXT("HIGHEND")) )
{
bHandledCommand = HandleHighendCommand( Cmd, Ar );
}
if (!bHandledCommand)
{
Ar.Logf(TEXT("Unrecognized system setting (note that console variables can be set much easier)"));
}
else
{
// Write the new settings to the INI.
SaveToIni();
}
}
return bHandledCommand;
}
FGlobalComponentReregisterContext::FGlobalComponentReregisterContext(const TArray<UClass*>& ExcludeComponents)
{
ActiveGlobalReregisterContextCount++;
// wait until resources are released
FlushRenderingCommands();
// Detach only actor components that are not in the excluded list
for (auto* Component : TObjectRange<UActorComponent>())
{
bool bShouldReregister=true;
for (UClass* ExcludeClass : ExcludeComponents)
{
if( ExcludeClass &&
Component->IsA(ExcludeClass) )
{
bShouldReregister = false;
break;
}
}
if( bShouldReregister )
{
new(ComponentContexts) FComponentReregisterContext(Component);
}
}
}
FGlobalComponentReregisterContext::FGlobalComponentReregisterContext(const TArray<AActor*>& InParentActors)
{
ActiveGlobalReregisterContextCount++;
// wait until resources are released
FlushRenderingCommands();
// Detach only actor components that are children of the actors list provided
for(TObjectIterator<UActorComponent> ComponentIt;ComponentIt;++ComponentIt)
{
bool bShouldReregister=false;
UPrimitiveComponent* PrimitiveComponent = Cast<UPrimitiveComponent>(*ComponentIt);
if (PrimitiveComponent && PrimitiveComponent->ReplacementPrimitive.Get())
{
UPrimitiveComponent* ReplacementPrimitive = PrimitiveComponent->ReplacementPrimitive.Get();
AActor* ParentActor = Cast<AActor>(ReplacementPrimitive->GetOuter());
if (ParentActor && InParentActors.Contains(ParentActor))
{
bShouldReregister = true;
}
}
if( bShouldReregister )
{
new(ComponentContexts) FComponentReregisterContext(*ComponentIt);
}
}
}
void FD3D11Viewport::ConditionalResetSwapChain(bool bIgnoreFocus)
{
if(!bIsValid)
{
// Check if the viewport's window is focused before resetting the swap chain's fullscreen state.
HWND FocusWindow = ::GetFocus();
const bool bIsFocused = FocusWindow == WindowHandle;
const bool bIsIconic = !!::IsIconic( WindowHandle );
if(bIgnoreFocus || (bIsFocused && !bIsIconic) )
{
FlushRenderingCommands();
// Store the current cursor clip rectangle as it can be lost when fullscreen is reset.
RECT OriginalCursorRect;
GetClipCursor(&OriginalCursorRect);
HRESULT Result = SwapChain->SetFullscreenState(bIsFullscreen,NULL);
if(SUCCEEDED(Result))
{
ClipCursor(&OriginalCursorRect);
bIsValid = true;
}
else
{
// Even though the docs say SetFullscreenState always returns S_OK, that doesn't always seem to be the case.
UE_LOG(LogD3D11RHI, Log, TEXT("IDXGISwapChain::SetFullscreenState returned %08x; waiting for the next frame to try again."),Result);
}
}
}
}
void FDebugViewModeMaterialProxy::ValidateAllShaders(OUT FTexCoordScaleMap& TexCoordScales)
{
FlushRenderingCommands();
for (TMap<const FMaterial*, FDebugViewModeMaterialProxy*>::TIterator It(DebugMaterialShaderMap); It; ++It)
{
const FMaterial* OriginalMaterial = It.Key();
FDebugViewModeMaterialProxy* DebugMaterial = It.Value();
if (OriginalMaterial && DebugMaterial && OriginalMaterial->GetGameThreadShaderMap() && DebugMaterial->GetGameThreadShaderMap())
{
const FUniformExpressionSet& DebugViewUniformExpressionSet = DebugMaterial->GetGameThreadShaderMap()->GetUniformExpressionSet();
const FUniformExpressionSet& OrignialUniformExpressionSet = OriginalMaterial->GetGameThreadShaderMap()->GetUniformExpressionSet();
if (!(DebugViewUniformExpressionSet == OrignialUniformExpressionSet))
{
// This will happen when the debug shader compiled misses logic. Usually caused by custom features in the original shader compilation not implemented in FDebugViewModeMaterialProxy.
UE_LOG(TextureStreamingBuild, Verbose, TEXT("Uniform expression set mismatch for %s, skipping shader"), *DebugMaterial->GetMaterialInterface()->GetName());
// Here we can't destroy the invalid material because it would trigger ClearAllShaders.
DebugMaterial->MarkAsInvalid();
TexCoordScales.Remove(DebugMaterial->GetMaterialInterface());
}
}
else if (DebugMaterial)
{
UE_LOG(TextureStreamingBuild, Verbose, TEXT("Can't get valid shadermap for %s, skipping shader"), *DebugMaterial->GetMaterialInterface()->GetName());
// Here we can't destroy the invalid material because it would trigger ClearAllShaders.
DebugMaterial->MarkAsInvalid();
TexCoordScales.Remove(DebugMaterial->GetMaterialInterface());
}
}
}
/** Initialization constructor. */
FNiagaraScriptCompileContext(UNiagaraScript* Script)
{
// wait until resources are released
FlushRenderingCommands();
// Reregister all components usimg Script.
for (TObjectIterator<UNiagaraComponent> ComponentIt; ComponentIt; ++ComponentIt)
{
UNiagaraComponent* Comp = *ComponentIt;
TSharedPtr<FNiagaraEffectInstance> Inst = Comp->GetEffectInstance();
if (Inst.IsValid())
{
TArray<TSharedPtr<FNiagaraSimulation>>& Emitters = Inst->GetEmitters();
for (TSharedPtr<FNiagaraSimulation> Sim : Emitters)
{
if (Sim.IsValid())
{
if (UNiagaraEmitterProperties* Props = Sim->GetProperties().Get())
{
if (Props->UpdateScriptProps.Script == Script)
{
new(ComponentContexts)FNiagaraComponentReregisterContext(Comp, &Props->UpdateScriptProps, Props);
}
else if (Props->SpawnScriptProps.Script == Script)
{
new(ComponentContexts)FNiagaraComponentReregisterContext(Comp, &Props->SpawnScriptProps, Props);
}
}
}
}
}
}
}
UDestructibleMesh* ImportDestructibleMeshFromApexDestructibleAsset(UObject* InParent, NxDestructibleAsset& ApexDestructibleAsset, FName Name, EObjectFlags Flags, FSkeletalMeshImportData* OutData, EDestructibleImportOptions::Type Options)
{
// The APEX Destructible Asset contains an APEX Render Mesh Asset, get a pointer to this
const physx::NxRenderMeshAsset* ApexRenderMesh = ApexDestructibleAsset.getRenderMeshAsset();
if (ApexRenderMesh == NULL)
{
return NULL;
}
// Number of submeshes (aka "elements" in Unreal)
const physx::PxU32 SubmeshCount = ApexRenderMesh->getSubmeshCount();
if (SubmeshCount == 0)
{
return NULL;
}
// Make sure rendering is done - so we are not changing data being used by collision drawing.
FlushRenderingCommands();
UDestructibleMesh* DestructibleMesh = FindObject<UDestructibleMesh>(InParent, *Name.ToString());
if (DestructibleMesh == NULL)
{
// Create the new UDestructibleMesh object if the one with the same name does not exist
DestructibleMesh = NewObject<UDestructibleMesh>(InParent, Name, Flags);
}
if (!(Options & EDestructibleImportOptions::PreserveSettings))
{
// Store the current file path and timestamp for re-import purposes
// @todo AssetImportData make a data class for Apex destructible assets
DestructibleMesh->AssetImportData = NewObject<UAssetImportData>(DestructibleMesh);
DestructibleMesh->AssetImportData->Update(UFactory::CurrentFilename);
DestructibleMesh->AssetImportData->bDirty = false;
}
DestructibleMesh->PreEditChange(NULL);
// Build FractureSettings from ApexDestructibleAsset in case we want to re-fracture
#if WITH_EDITORONLY_DATA
DestructibleMesh->CreateFractureSettings();
DestructibleMesh->FractureSettings->BuildRootMeshFromApexDestructibleAsset(ApexDestructibleAsset, Options);
// Fill materials
DestructibleMesh->FractureSettings->Materials.Reset(DestructibleMesh->Materials.Num());
for (int32 MaterialIndex = 0; MaterialIndex < DestructibleMesh->Materials.Num(); ++MaterialIndex)
{
DestructibleMesh->FractureSettings->Materials.Insert(DestructibleMesh->Materials[MaterialIndex].MaterialInterface, MaterialIndex);
}
#endif // WITH_EDITORONLY_DATA
if (!SetApexDestructibleAsset(*DestructibleMesh, ApexDestructibleAsset, OutData, Options))
{
// should remove this destructible mesh. if not, this object causes a crash when ticking because it doesn't have proper rendering resources
// @TODO : creates this destructible mesh after loading data completely
DestructibleMesh->PostEditChange();
DestructibleMesh->ConditionalBeginDestroy();
return NULL;
}
return DestructibleMesh;
}
void UNiagaraComponent::OnRegister()
{
Super::OnRegister();
if (Asset)
{
if (!EffectInstance)
{
EffectInstance = new FNiagaraEffectInstance(Asset, this);
}
{
EffectInstance->Init(this);
// initialize all render modules
ENQUEUE_UNIQUE_RENDER_COMMAND_TWOPARAMETER(
FChangeNiagaraRenderModule,
FNiagaraEffectInstance*, InEffect, this->EffectInstance,
UNiagaraComponent*, InComponent, this,
{
for (TSharedPtr<FNiagaraSimulation> Emitter : InEffect->GetEmitters())
{
Emitter->SetRenderModuleType(Emitter->GetProperties()->RenderModuleType, InComponent->GetWorld()->FeatureLevel);
}
InEffect->RenderModuleupdate();
}
);
FlushRenderingCommands();
}
VectorVM::Init();
}
/** Invalidates the light's cached lighting with the option to recreate the light Guids. */
void ULightComponent::InvalidateLightingCacheInner(bool bRecreateLightGuids)
{
// Save the light state for transactions.
Modify();
// Detach the component from the scene for the duration of this function.
FComponentReregisterContext ReregisterContext(this);
// Block until the RT processes the unregister before modifying variables that it may need to access
FlushRenderingCommands();
StaticShadowDepthMap.Empty();
BeginReleaseResource(&StaticShadowDepthMap);
bPrecomputedLightingIsValid = false;
if (bRecreateLightGuids)
{
// Create new guids for light.
UpdateLightGUIDs();
}
else
{
ValidateLightGUIDs();
ShadowMapChannel = INDEX_NONE;
}
// Send to render thread
MarkRenderStateDirty();
}
FGlobalComponentReregisterContext::FGlobalComponentReregisterContext(const TArray<UClass*>& ExcludeComponents)
{
ActiveGlobalReregisterContextCount++;
// wait until resources are released
FlushRenderingCommands();
// Detach only actor components that are not in the excluded list
for(TObjectIterator<UActorComponent> ComponentIt;ComponentIt;++ComponentIt)
{
bool bShouldReregister=true;
for( int32 Idx=0; Idx < ExcludeComponents.Num(); Idx++ )
{
UClass* ExcludeClass = ExcludeComponents[Idx];
if( ExcludeClass &&
ComponentIt->IsA(ExcludeClass) )
{
bShouldReregister = false;
break;
}
}
if( bShouldReregister )
{
new(ComponentContexts) FComponentReregisterContext(*ComponentIt);
}
}
}
void BeginRecompileGlobalShaders(const TArray<FShaderType*>& OutdatedShaderTypes, EShaderPlatform ShaderPlatform)
{
if( !FPlatformProperties::RequiresCookedData() )
{
// Flush pending accesses to the existing global shaders.
FlushRenderingCommands();
TShaderMap<FGlobalShaderType>* GlobalShaderMap = GetGlobalShaderMap(ShaderPlatform);
for (int32 TypeIndex = 0; TypeIndex < OutdatedShaderTypes.Num(); TypeIndex++)
{
FGlobalShaderType* CurrentGlobalShaderType = OutdatedShaderTypes[TypeIndex]->GetGlobalShaderType();
if (CurrentGlobalShaderType)
{
UE_LOG(LogShaders, Log, TEXT("Flushing Global Shader %s"), CurrentGlobalShaderType->GetName());
GlobalShaderMap->RemoveShaderType(CurrentGlobalShaderType);
//invalidate global bound shader states so they will be created with the new shaders the next time they are set (in SetGlobalBoundShaderState)
for(TLinkedList<FGlobalBoundShaderStateResource*>::TIterator It(FGlobalBoundShaderStateResource::GetGlobalBoundShaderStateList());It;It.Next())
{
BeginUpdateResourceRHI(*It);
}
}
}
VerifyGlobalShaders(ShaderPlatform, false);
}
}
FMediaFoundationMovieStreamer::~FMediaFoundationMovieStreamer()
{
CloseMovie();
CleanupRenderingResources();
FlushRenderingCommands();
TextureFreeList.Empty();
}
void FLODUtilities::RemoveLOD(FSkeletalMeshUpdateContext& UpdateContext, int32 DesiredLOD )
{
USkeletalMesh* SkeletalMesh = UpdateContext.SkeletalMesh;
FSkeletalMeshResource* SkelMeshResource = SkeletalMesh->GetImportedResource();
if( SkelMeshResource->LODModels.Num() == 1 )
{
FMessageDialog::Open( EAppMsgType::Ok, NSLOCTEXT("UnrealEd", "NoLODToRemove", "No LODs to remove!") );
return;
}
// Now display combo to choose which LOD to remove.
TArray<FString> LODStrings;
LODStrings.AddZeroed( SkelMeshResource->LODModels.Num()-1 );
for(int32 i=0; i<SkelMeshResource->LODModels.Num()-1; i++)
{
LODStrings[i] = FString::Printf( TEXT("%d"), i+1 );
}
check( SkeletalMesh->LODInfo.Num() == SkelMeshResource->LODModels.Num() );
// If its a valid LOD, kill it.
if( DesiredLOD > 0 && DesiredLOD < SkelMeshResource->LODModels.Num() )
{
//We'll be modifying the skel mesh data so reregister
//TODO - do we need to reregister something else instead?
FMultiComponentReregisterContext ReregisterContext(UpdateContext.AssociatedComponents);
// Release rendering resources before deleting LOD
SkelMeshResource->ReleaseResources();
// Block until this is done
FlushRenderingCommands();
SkelMeshResource->LODModels.RemoveAt(DesiredLOD);
SkeletalMesh->LODInfo.RemoveAt(DesiredLOD);
SkeletalMesh->InitResources();
RefreshLODChange(SkeletalMesh);
// Set the forced LOD to Auto.
for(auto Iter = UpdateContext.AssociatedComponents.CreateIterator(); Iter; ++Iter)
{
USkinnedMeshComponent* SkinnedComponent = Cast<USkinnedMeshComponent>(*Iter);
if(SkinnedComponent)
{
SkinnedComponent->ForcedLodModel = 0;
}
}
//Notify calling system of change
UpdateContext.OnLODChanged.ExecuteIfBound();
// Mark things for saving.
SkeletalMesh->MarkPackageDirty();
}
}
FDefaultGameMoviePlayer::~FDefaultGameMoviePlayer()
{
if( bInitialized )
{
// This should not happen if initialize was called correctly. This is a fallback to ensure that the movie player rendering tickable gets unregistered on the rendering thread correctly
Shutdown();
FlushRenderingCommands();
}
}
FTileItemThumbnail::~FTileItemThumbnail()
{
BeginReleaseResource(ThumbnailTexture);
// Wait for all resources to be released
FlushRenderingCommands();
delete ThumbnailTexture;
ThumbnailTexture = NULL;
}
virtual void StartupModule() override
{
// register settings detail panel customization
FPropertyEditorModule& PropertyModule = FModuleManager::LoadModuleChecked<FPropertyEditorModule>("PropertyEditor");
PropertyModule.RegisterCustomClassLayout(
"IOSRuntimeSettings",
FOnGetDetailCustomizationInstance::CreateStatic(&FIOSTargetSettingsCustomization::MakeInstance)
);
FOnUpdateMaterialShaderQuality UpdateMaterials = FOnUpdateMaterialShaderQuality::CreateLambda([]()
{
FGlobalComponentRecreateRenderStateContext Recreate;
FlushRenderingCommands();
UMaterial::AllMaterialsCacheResourceShadersForRendering();
UMaterialInstance::AllMaterialsCacheResourceShadersForRendering();
});
PropertyModule.RegisterCustomClassLayout(
UShaderPlatformQualitySettings::StaticClass()->GetFName(),
FOnGetDetailCustomizationInstance::CreateStatic(&FMaterialShaderQualitySettingsCustomization::MakeInstance, UpdateMaterials)
);
PropertyModule.NotifyCustomizationModuleChanged();
// register settings
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
SettingsModule->RegisterSettings("Project", "Platforms", "iOS",
LOCTEXT("RuntimeSettingsName", "iOS"),
LOCTEXT("RuntimeSettingsDescription", "Settings and resources for the iOS platform"),
GetMutableDefault<UIOSRuntimeSettings>()
);
{
static FName NAME_OPENGL_ES2_IOS(TEXT("GLSL_ES2_IOS"));
const UShaderPlatformQualitySettings* IOSMaterialQualitySettings = UMaterialShaderQualitySettings::Get()->GetShaderPlatformQualitySettings(NAME_OPENGL_ES2_IOS);
SettingsModule->RegisterSettings("Project", "Platforms", "iOSES2Quality",
LOCTEXT("IOSES2QualitySettingsName", "iOS Material Quality - ES2"),
LOCTEXT("IOSES2QualitySettingsDescription", "Settings for iOS ES2 material quality"),
IOSMaterialQualitySettings
);
}
{
static FName NAME_SF_METAL(TEXT("SF_METAL"));
const UShaderPlatformQualitySettings* IOSMaterialQualitySettings = UMaterialShaderQualitySettings::Get()->GetShaderPlatformQualitySettings(NAME_SF_METAL);
SettingsModule->RegisterSettings("Project", "Platforms", "iOSMetalQuality",
LOCTEXT("IOSMetalQualitySettingsName", "iOS Material Quality - Metal"),
LOCTEXT("IOSMetalQualitySettingsDescription", "Settings for iOS Metal material quality"),
IOSMaterialQualitySettings
);
}
}
}
UDestructibleMesh* ImportDestructibleMeshFromApexDestructibleAsset(UObject* InParent, NxDestructibleAsset& ApexDestructibleAsset, FName Name, EObjectFlags Flags, FSkeletalMeshImportData* OutData, EImportOptions::Type Options)
{
// The APEX Destructible Asset contains an APEX Render Mesh Asset, get a pointer to this
const physx::NxRenderMeshAsset* ApexRenderMesh = ApexDestructibleAsset.getRenderMeshAsset();
if (ApexRenderMesh == NULL)
{
return NULL;
}
// Number of submeshes (aka "elements" in Unreal)
const physx::PxU32 SubmeshCount = ApexRenderMesh->getSubmeshCount();
if (SubmeshCount == 0)
{
return NULL;
}
// Make sure rendering is done - so we are not changing data being used by collision drawing.
FlushRenderingCommands();
UDestructibleMesh* DestructibleMesh = FindObject<UDestructibleMesh>(InParent, *Name.ToString());
if (DestructibleMesh == NULL)
{
// Create the new UDestructibleMesh object if the one with the same name does not exist
DestructibleMesh = CastChecked<UDestructibleMesh>(StaticConstructObject(UDestructibleMesh::StaticClass(), InParent, Name, Flags));
}
if (!(Options & EImportOptions::PreserveSettings))
{
// Store the current file path and timestamp for re-import purposes
// @todo AssetImportData make a data class for Apex destructible assets
DestructibleMesh->AssetImportData = ConstructObject<UAssetImportData>(UAssetImportData::StaticClass(), DestructibleMesh);
DestructibleMesh->AssetImportData->SourceFilePath = FReimportManager::SanitizeImportFilename(UFactory::CurrentFilename, DestructibleMesh);
DestructibleMesh->AssetImportData->SourceFileTimestamp = IFileManager::Get().GetTimeStamp(*UFactory::CurrentFilename).ToString();
}
DestructibleMesh->PreEditChange(NULL);
// Build FractureSettings from ApexDestructibleAsset in case we want to re-fracture
#if WITH_EDITORONLY_DATA
DestructibleMesh->CreateFractureSettings();
DestructibleMesh->FractureSettings->BuildRootMeshFromApexDestructibleAsset(ApexDestructibleAsset, Options);
// Fill materials
DestructibleMesh->FractureSettings->Materials.Reset(DestructibleMesh->Materials.Num());
for (int32 MaterialIndex = 0; MaterialIndex < DestructibleMesh->Materials.Num(); ++MaterialIndex)
{
DestructibleMesh->FractureSettings->Materials.Insert(DestructibleMesh->Materials[MaterialIndex].MaterialInterface, MaterialIndex);
}
#endif // WITH_EDITORONLY_DATA
if (!SetApexDestructibleAsset(*DestructibleMesh, ApexDestructibleAsset, OutData, Options))
{
return NULL;
}
return DestructibleMesh;
}
void AddComponentToRefresh(UActorComponent* Component)
{
if (ComponentContexts.Num() == 0)
{
// wait until resources are released
FlushRenderingCommands();
}
new (ComponentContexts) FComponentReregisterContext(Component);
}
void FVulkanPipelineStateCache::RebuildCache()
{
UE_LOG(LogVulkanRHI, Warning, TEXT("Rebuilding pipeline cache; ditching %d entries"), DiskEntries.Num());
if (IsInGameThread())
{
FlushRenderingCommands();
}
DestroyCache();
}
FGlobalComponentRecreateRenderStateContext::FGlobalComponentRecreateRenderStateContext()
{
// wait until resources are released
FlushRenderingCommands();
// recreate render state for all components.
for (auto* Component : TObjectRange<UActorComponent>())
{
new(ComponentContexts) FComponentRecreateRenderStateContext(Component);
}
}
FShotThumbnail::~FShotThumbnail()
{
BeginReleaseResource( Texture );
FlushRenderingCommands();
if (Texture)
{
delete Texture;
}
}
FGlobalComponentReregisterContext::FGlobalComponentReregisterContext()
{
ActiveGlobalReregisterContextCount++;
// wait until resources are released
FlushRenderingCommands();
// Detach all actor components.
for(TObjectIterator<UActorComponent> ComponentIt;ComponentIt;++ComponentIt)
{
new(ComponentContexts) FComponentReregisterContext(*ComponentIt);
}
}
FGlobalComponentReregisterContext::FGlobalComponentReregisterContext()
{
ActiveGlobalReregisterContextCount++;
// wait until resources are released
FlushRenderingCommands();
// Detach all actor components.
for(auto* Component : TObjectRange<UActorComponent>())
{
new(ComponentContexts) FComponentReregisterContext(Component);
}
}
void FDebugViewModeMaterialProxy::ClearAllShaders()
{
if (bReentrantCall || DebugMaterialShaderMap.Num() == 0) return;
FlushRenderingCommands();
bReentrantCall = true;
for (TMap<const FMaterial*, FDebugViewModeMaterialProxy*>::TIterator It(DebugMaterialShaderMap); It; ++It)
{
FDebugViewModeMaterialProxy* Proxy = It.Value();
delete Proxy;
}
DebugMaterialShaderMap.Empty();
bReentrantCall = false;
}
/**
* Helper for ApplyNewSettings when the engine is running. Applies the changes needed for the runtime system.
*
* We can assume the game is running if this code is called.
*/
void FSystemSettings::ApplySettingsAtRuntime(const FSystemSettingsData& NewSettings, bool bWriteToIni)
{
// Some of these settings are shared between threads, so we
// must flush the rendering thread before changing anything.
FlushRenderingCommands();
// Track settings we might have to put back
FExposedTextureLODSettings InMemoryTextureLODSettings = TextureLODSettings;
// Read settings from .ini. This is necessary because settings which need to wait for a restart
// will be on disk but may not be in memory. Therefore, we read from disk before capturing old
// values to revert to.
LoadFromIni();
// see what settings are actually changing.
// Ugly casts because system settings is multi-inherited from all the consituent classes for backwards compatibility
// Texture Detail
bool bTextureDetailChanged = (const FSystemSettingsDataTextureDetail&)(*this) != (const FSystemSettingsDataTextureDetail&)NewSettings;
// Make a copy of the existing settings so we can compare for changes
FSystemSettingsData OldData = *this;
// Set new settings. Would look prettier if we didn't derive from the Data class...
(FSystemSettingsData&)(*this) = NewSettings;
// apply any runtime changes that need to be made
bool bUpdateTextureStreamingSucceeded = false;
if (bTextureDetailChanged)
{
bUpdateTextureStreamingSucceeded = UTexture::ForceUpdateTextureStreaming();
}
// If requested, save the settings to ini.
if ( bWriteToIni )
{
SaveToIni();
}
// If texture detail settings couldn't be applied because we're loading seekfree,
// revert the new settings to their previous in-memory values.
if ( bTextureDetailChanged && !bUpdateTextureStreamingSucceeded )
{
TextureLODSettings = InMemoryTextureLODSettings;
}
}
void UVaQuoleUIComponent::DestroyUITexture()
{
if (Texture)
{
Texture->RemoveFromRoot();
if (Texture->Resource)
{
BeginReleaseResource(Texture->Resource);
FlushRenderingCommands();
}
Texture->MarkPendingKill();
Texture = nullptr;
}
}
