Unity开发者联盟收藏本站
发帖教程新人必读切换到宽版

 找回密码
 立即注册
Unity开发者联盟»论坛 › 3D Answers 技术讨论 › 技术讨论 Technology Answers › UE资源热重载方案
返回列表 发新帖
查看: 571|回复: 0

UE资源热重载方案

[复制链接]
发表于 2021-4-28 09:18 | 显示全部楼层 |阅读模式
问题说明：

手游项目中资源热更是非常频繁的，很多项目会在运行过程中支持资源热更。
但是资源热更后，要不就强迫用户重启app，要不就app内重新启动。
方案说明：

接触Unreal后，我也一直在思考app内热重启的方案，这里给大家分享一下我的做法：
首先，热重启最重要问题就是：该如何释放呢？
释放主要方面：
1.释放UnLua
   清理luastate，清理UnLua组件
2.UGameInstance释放，参考PIE的Play&Stop
    主要是调用其Shutdown()接口进行清理，并不会释放UGameInstance对象
3.空场景释放资源，Unmount所有pak
4.最后通过GC进行UObject清理（分帧做两次强制GC，第二次GC是为了阻塞完成回收第一次GC收集的不可达对象）
    为了减少资源的引用，然后通过GC尽可能多释放UObject
方案思路解释：

方案的核心主要是UGameInstance::Shutdown()，而为什么是UGameInstance呢？为什么不是更高级的UEngine或者是更低级的AGameMode呢？
首先，选择UGameInstance是因为参考的PIE的Play&Stop。从Unity转到Unreal的同学应该发现一个问题：
      同样是PIE(Play in Editor)，Unity得益于.Net平台在每次Play都可以新建一个完全独立的虚拟机进行代码托管，而Unreal使用C++每次Play都是同一个执行环境。使用Unity开发基本不需要考虑Stop后的清理释放流程，而Unreal则需要谨慎处理Stop时数据缓存和委托监听等清理释放问题。
万事都有双面性，虽然这这点上Unreal没有Unity那样方便，但也得益于Unreal这个问题，促使我们在开发中要保证Stop时进行充分的清理，否则开发阶段就会出现问题。
由此，也可以得出，参考PIE的Stop&Play过程是不是也可以实现我们App中的Stop&Play了呢。


"怎么来的"(分析PIE的Stop流程,比较啰嗦,可以直接跳到后面怎么来的分割线):
调试PIE的Stop，就发现最终就会执行到UGameInstance::Shutdown()。
那我们就仔细看看PIE的Stop做了什么.
Stop后，实际是调用了RequestEndPlayMap
查看RequestEndPlayMap的代码，发现主要是设置了bRequestEndPlayMapQueued=true
至于这个bRequestEndPlayMapQueued会触发什么逻辑呢？
1.暂停播放音频，只是暂停，不是释放，所以我们不关心
2.调用EndPlayMap
好了，重点看一下EndPlayMap，篇幅有限，省略部分部分代码，下面以中文注释进行解释：
  1. void UEditorEngine::EndPlayMap()
  2. {
  3.         FlushAsyncLoading();  //阻塞完成所有异步加载请求------[必要]
  5.         //VR,AR,MR的重置操作,这只是PIE的Stop需要--------------[不需要]
  6.         if (GEngine->XRSystem.IsValid() && !bIsSimulatingInEditor)
  7.         {
  8.                 GEngine->XRSystem->OnEndPlay(*GEngine->GetWorldContextFromWorld(PlayWorld));
  9.         }
  10.         
  11.         //清理Viewport,这只是PIE的Stop需要，热重启并不希望-----[不需要]
  12.         // clean up any previous Play From Here sessions
  13.         if ( GameViewport != NULL && GameViewport->Viewport != NULL )
  14.         {
  15.                 // Remove debugger commands handler binding
  16.                 GameViewport->OnGameViewportInputKey().Unbind();
  18.                 // Remove close handler binding
  19.                 GameViewport->OnCloseRequested().Remove(ViewportCloseRequestedDelegateHandle);
  21.                 GameViewport->CloseRequested(GameViewport->Viewport);
  22.         }
  23.         CleanupGameViewport();
  25.         //清理所有World，热重启并不希望清理当前World-----[不需要]
  26.         // Clean up each world individually
  27.         TArray<FName> OnlineIdentifiers;
  28.         TArray<UWorld*> WorldsBeingCleanedUp;
  29.         bool bSeamlessTravelActive = false;
  30.         for (int32 WorldIdx = WorldList.Num()-1; WorldIdx >= 0; --WorldIdx)
  31.         {
  32.                 FWorldContext &ThisContext = WorldList[WorldIdx];
  33.                 if (ThisContext.WorldType == EWorldType::PIE)
  34.                 {
  35.                         if (ThisContext.World())
  36.                         {
  37.                                 WorldsBeingCleanedUp.Add(ThisContext.World());
  38.                         }
  40.                         if (ThisContext.SeamlessTravelHandler.IsInTransition())
  41.                         {
  42.                                 bSeamlessTravelActive = true;
  43.                         }
  45.                         if (ThisContext.World())
  46.                         {
  47.                                 //但是这里有个例外，这里使用WorldContext进行TeardownPlaySession，
  48.                                 //WorldContext在UE里主要是代表一个LocalPlayer，
  49.                                 //做的事情可能并不止于World内，
  50.                                 //所以需要留意，后面会展开解释 --------------------------- [必要]
  51.                                 TeardownPlaySession(ThisContext);
  53.                                 ShutdownWorldNetDriver(ThisContext.World());
  54.                         }
  56.                         // Cleanup online subsystems instantiated during PIE
  57.                         FName OnlineIdentifier = UOnlineEngineInterface::Get()->GetOnlineIdentifier(ThisContext);
  58.                         if (UOnlineEngineInterface::Get()->DoesInstanceExist(OnlineIdentifier))
  59.                         {
  60.                                 // Stop ticking and clean up, but do not destroy as we may be in a failed online delegate
  61.                                 UOnlineEngineInterface::Get()->ShutdownOnlineSubsystem(OnlineIdentifier);
  62.                                 OnlineIdentifiers.Add(OnlineIdentifier);
  63.                         }
  64.                
  65.                         // Remove world list after online has shutdown in case any async actions require the world context
  66.                         WorldList.RemoveAt(WorldIdx);
  67.                 }
  68.         }
  70.         // SeamlessTravel相关，我们热重启的时候会切换到一个稳定的空场景，
  71.         //所以不需要考虑SeamlessTravel ----- [不需要]
  72.         // If seamless travel is happening then there is likely additional PIE worlds that need tearing down so seek them out
  73.         if (bSeamlessTravelActive)
  74.         {
  75.                 for (TObjectIterator<UWorld> WorldIt; WorldIt; ++WorldIt)
  76.                 {
  77.                         if (WorldIt->IsPlayInEditor())
  78.                         {
  79.                                 WorldsBeingCleanedUp.AddUnique(*WorldIt);
  80.                         }
  81.                 }
  82.         }
  83.         
  84.         //清理World的时候产生的OnlineIdentifiers，所以不考虑  ---- [不需要]
  85.         if (OnlineIdentifiers.Num())
  86.         {
  87.                 UE_LOG(LogPlayLevel, Display, TEXT("Shutting down PIE online subsystems"));
  88.                 // Cleanup online subsystem shortly as we might be in a failed delegate
  89.                 // have to do this in batch because timer delegate doesn't recognize bound data
  90.                 // as a different delegate
  91.                 FTimerDelegate DestroyTimer;
  92.                 DestroyTimer.BindUObject(this, &UEditorEngine::CleanupPIEOnlineSessions, OnlineIdentifiers);
  93.                 GetTimerManager()->SetTimer(CleanupPIEOnlineSessionsTimerHandle, DestroyTimer, 0.1f, false);
  94.         }
  95.        
  96.         //广播EndPlayMap委托事件，因为我们是模拟Stop，并不想在PIE的时候真的触发了EndPlay ----- [不需要]
  97.         FGameDelegates::Get().GetEndPlayMapDelegate().Broadcast();
  98.        
  99.          //清理outer带PKG_PlayInEditor标签的standalone UObject  --- [不需要]
  100.         // find objects like Textures in the playworld levels that won't get garbage collected as they are marked RF_Standalone
  101.         for (FObjectIterator It; It; ++It)
  102.         {
  103.                 UObject* Object = *It;
  105.                 if (Object->GetOutermost()->HasAnyPackageFlags(PKG_PlayInEditor))
  106.                 {
  107.                         if (Object->HasAnyFlags(RF_Standalone))
  108.                         {
  109.                                 // Clear RF_Standalone flag from objects in the levels used for PIE so they get cleaned up.
  110.                                 Object->ClearFlags(RF_Standalone);
  111.                         }
  112.                         // Close any asset editors that are currently editing this object
  113.                         GEditor->GetEditorSubsystem<UAssetEditorSubsystem>()->CloseAllEditorsForAsset(Object);
  114.                 }
  115.         }
  117.         //不是释放逻辑,我们不关心    ---- [不需要]
  118.         EditorWorld->bAllowAudioPlayback = true;
  119.         EditorWorld = nullptr;
  121.         //清理World带来的逻辑   --------------- [不需要]
  122.         // mark everything contained in the PIE worlds to be deleted
  123.         for (UWorld* World : WorldsBeingCleanedUp)
  124.         {
  125.                 // Occasionally during seamless travel the Levels array won't yet be populated so mark this world first
  126.                 // then pick up the sub-levels via the level iterator
  127.                 World->MarkObjectsPendingKill();
  128.                
  129.                 // Because of the seamless travel the world might still be in the root set too, so also clear that
  130.                 World->RemoveFromRoot();
  132.                 for (auto LevelIt(World->GetLevelIterator()); LevelIt; ++LevelIt)
  133.                 {
  134.                         if (const ULevel* Level = *LevelIt)
  135.                         {
  136.                                 // We already picked up the persistent level with the top level mark objects
  137.                                 if (Level->GetOuter() != World)
  138.                                 {
  139.                                         CastChecked<UWorld>(Level->GetOuter())->MarkObjectsPendingKill();
  140.                                 }
  141.                         }
  142.                 }
  144.                 for (ULevelStreaming* LevelStreaming : World->GetStreamingLevels())
  145.                 {
  146.                         // If an unloaded levelstreaming still has a loaded level we need to mark its objects to be deleted as well
  147.                         if (LevelStreaming->GetLoadedLevel() && (!LevelStreaming->ShouldBeLoaded() || !LevelStreaming->ShouldBeVisible()))
  148.                         {
  149.                                 CastChecked<UWorld>(LevelStreaming->GetLoadedLevel()->GetOuter())->MarkObjectsPendingKill();
  150.                         }
  151.                 }
  152.         }
  154.         //强制清理GameInstance中的所有UObject，我们只是考虑模拟Shutdown，并不需要强制清理 --- [不需要]
  155.         // mark all objects contained within the PIE game instances to be deleted
  156.         for (TObjectIterator<UGameInstance> It; It; ++It)
  157.         {
  158.                 auto MarkObjectPendingKill = [](UObject* Object)
  159.                 {
  160.                         Object->MarkPendingKill();
  161.                 };
  162.                 ForEachObjectWithOuter(*It, MarkObjectPendingKill, true, RF_NoFlags, EInternalObjectFlags::PendingKill);
  163.         }
  165.         // 清理Slate的所有渲染状态，由于是在稳定的空场景里面，展示的UI也是不需要释放的，所以 --- [不需要]
  166.         // Flush any render commands and released accessed UTextures and materials to give them a chance to be collected.
  167.         if ( FSlateApplication::IsInitialized() )
  168.         {
  169.                 FSlateApplication::Get().FlushRenderState();
  170.         }
  172.          //只是做一下检查，检查结果打印一下而已，不涉及到释放  ---- [不需要]
  173.         // Make sure that all objects in the temp levels were entirely garbage collected.
  174.         for( FObjectIterator ObjectIt; ObjectIt; ++ObjectIt )
  175.         {
  176.                 UObject* Object = *ObjectIt;
  177.                 if( Object->GetOutermost()->HasAnyPackageFlags(PKG_PlayInEditor))
  178.                 {
  179.                         UWorld* TheWorld = UWorld::FindWorldInPackage(Object->GetOutermost());
  180.                         if ( TheWorld )
  181.                         {
  182.                                 StaticExec(nullptr, *FString::Printf(TEXT("OBJ REFS CLASS=WORLD NAME=%s"), *TheWorld->GetPathName()));
  183.                         }
  184.                         else
  185.                         {
  186.                                 UE_LOG(LogPlayLevel, Error, TEXT("No PIE world was found when attempting to gather references after GC."));
  187.                         }
  189.                         FReferenceChainSearch RefChainSearch(Object, EReferenceChainSearchMode::Shortest);
  191.                         FFormatNamedArguments Arguments;
  192.                         Arguments.Add(TEXT("Path"), FText::FromString(RefChainSearch.GetRootPath()));
  193.                                
  194.                         // We cannot safely recover from this.
  195.                         FMessageLog(NAME_CategoryPIE).CriticalError()
  196.                                 ->AddToken(FUObjectToken::Create(Object, FText::FromString(Object->GetFullName())))
  197.                                 ->AddToken(FTextToken::Create(FText::Format(LOCTEXT("PIEObjectStillReferenced", "Object from PIE level still referenced. Shortest path from root: {Path}"), Arguments)));
  198.                 }
  199.         }
  201.         // Final cleanup/reseting
  202.         FWorldContext& EditorWorldContext = GEditor->GetEditorWorldContext();
  203.         UPackage* Package = EditorWorldContext.World()->GetOutermost();
  205.         // 重置Stereo状态，不涉及到释放  --- [不需要]
  206.         //ensure stereo rendering is disabled in case we need to re-enable next PIE run (except when the editor is running in VR)
  207.         bool bInVRMode = IVREditorModule::Get().IsVREditorModeActive();
  208.         if (GEngine->StereoRenderingDevice && !bInVRMode)
  209.         {
  210.                 GEngine->StereoRenderingDevice->EnableStereo(false);
  211.         }
  212.       
  213.         //热重启不应该涉及到Viewport的清理，所以不需要   ---- [不需要]
  214.         // Restores realtime viewports that have been disabled for PIE.
  215.         RemoveViewportsRealtimeOverride();
  216.       
  217.         //重新注册音频组件，不涉及到释放  --- [不需要]
  218.         for(TObjectIterator<UAudioComponent> It; It; ++It)
  219.         {
  220.                 UAudioComponent* AudioComp = *It;
  221.                 if (AudioComp->GetWorld() == EditorWorldContext.World())
  222.                 {
  223.                         AudioComp->ReregisterComponent();
  224.                 }
  225.         }
  227.         //清理所有的Play回话,热重启不需要  --- [不需要]
  228.         // no longer queued
  229.         CancelRequestPlaySession();
  230.         bRequestEndPlayMapQueued = false;
  231. }
复制代码
最后总结需要在热重启里面做只剩下两个：
     1.FlushAsyncLoading()
     2.TeardownPlaySession(ThisContext);


其中FlushAsyncLoading()就不多说了，继续研究一下TeardownPlaySession：
  1. void UEditorEngine::TeardownPlaySession(FWorldContext& PieWorldContext)
  2. {
  3.         //销毁World，因为热重启会在一个稳定的空场景里，所以不需要销毁World   ---[不需要]
  4.         check(PieWorldContext.WorldType == EWorldType::PIE);
  5.         PlayWorld = PieWorldContext.World();
  6.         PlayWorld->BeginTearingDown();
  8.         if (!PieWorldContext.RunAsDedicated)
  9.         {
  10.                 // Slate data for this pie world
  11.                 FSlatePlayInEditorInfo* const SlatePlayInEditorSession = SlatePlayInEditorMap.Find(PieWorldContext.ContextHandle);
  13.                 //销毁ViewPort，热重启不希望销毁Viewport，所以不需要   ----[不需要]
  14.                 // Destroy Viewport
  15.                 if ( PieWorldContext.GameViewport != NULL && PieWorldContext.GameViewport->Viewport != NULL )
  16.                 {
  17.                         PieWorldContext.GameViewport->CloseRequested(PieWorldContext.GameViewport->Viewport);
  18.                 }
  19.                 CleanupGameViewport();
  20.        
  21.                 //清理PIEviewport   -------------------------------[不需要]
  22.                 // Clean up the slate PIE viewport if we have one
  23.                 if (SlatePlayInEditorSession)
  24.                 {
  25.                         if (SlatePlayInEditorSession->DestinationSlateViewport.IsValid())
  26.                         {
  27.                                 TSharedPtr<IAssetViewport> Viewport = SlatePlayInEditorSession->DestinationSlateViewport.Pin();
  29.                                 if(PlayInEditorSessionInfo->OriginalRequestParams.WorldType == EPlaySessionWorldType::PlayInEditor)
  30.                                 {
  31.                                         // Set the editor viewport location to match that of Play in Viewport if we aren't simulating in the editor, we have a valid player to get the location from (unless we're going back to VR Editor, in which case we won't teleport the user.)
  32.                                         if (bLastViewAndLocationValid == true && !GEngine->IsStereoscopic3D( Viewport->GetActiveViewport() ) )
  33.                                         {
  34.                                                 bLastViewAndLocationValid = false;
  35.                                                 Viewport->GetAssetViewportClient().SetViewLocation( LastViewLocation );
  37.                                                 if( Viewport->GetAssetViewportClient().IsPerspective() )
  38.                                                 {
  39.                                                         // Rotation only matters for perspective viewports not orthographic
  40.                                                         Viewport->GetAssetViewportClient().SetViewRotation( LastViewRotation );
  41.                                                 }
  42.                                         }
  43.                                 }
  45.                                 // No longer simulating in the viewport
  46.                                 Viewport->GetAssetViewportClient().SetIsSimulateInEditorViewport( false );
  48.                                
  49.                                 FEditorModeRegistry::Get().UnregisterMode(FBuiltinEditorModes::EM_Physics);
  50.                                
  52.                                 // Clear out the hit proxies before GC'ing
  53.                                 Viewport->GetAssetViewportClient().Viewport->InvalidateHitProxy();
  54.                         }
  55.                         else if (SlatePlayInEditorSession->SlatePlayInEditorWindow.IsValid())
  56.                         {
  57.                                 // Unregister the game viewport from slate.  This sends a final message to the viewport
  58.                                 // so it can have a chance to release mouse capture, mouse lock, etc.               
  59.                                 FSlateApplication::Get().UnregisterGameViewport();
  61.                                 // Viewport client is cleaned up.  Make sure its not being accessed
  62.                                 SlatePlayInEditorSession->SlatePlayInEditorWindowViewport->SetViewportClient(NULL);
  64.                                 // The window may have already been destroyed in the case that the PIE window close box was pressed
  65.                                 if (SlatePlayInEditorSession->SlatePlayInEditorWindow.IsValid())
  66.                                 {
  67.                                         // Destroy the SWindow
  68.                                         FSlateApplication::Get().DestroyWindowImmediately(SlatePlayInEditorSession->SlatePlayInEditorWindow.Pin().ToSharedRef());
  69.                                 }
  70.                         }
  71.                 }
  72.        
  73.                 //LocalPlayer是玩家实例，代表一个本地玩家 ---- [不需要]
  74.                 // Disassociate the players from their PlayerControllers.
  75.                 // This is done in the GameEngine path in UEngine::LoadMap.
  76.                 // But since PIE is just shutting down, and not loading a
  77.                 // new map, we need to do it manually here for now.
  78.                 //for (auto It = GEngine->GetLocalPlayerIterator(PlayWorld); It; ++It)
  79.                 for (FLocalPlayerIterator It(GEngine, PlayWorld); It; ++It)
  80.                 {
  81.                         if(It->PlayerController)
  82.                         {
  83.                                 if(It->PlayerController->GetPawn())
  84.                                 {
  85.                                         PlayWorld->DestroyActor(It->PlayerController->GetPawn(), true);
  86.                                 }
  87.                                 PlayWorld->DestroyActor(It->PlayerController, true);
  88.                                 It->PlayerController = NULL;
  89.                         }
  90.                 }
  92.         }
  94.         // Change GWorld to be the play in editor world during cleanup.
  95.         ensureMsgf( EditorWorld == GWorld, TEXT("TearDownPlaySession current world: %s"), GWorld ? *GWorld->GetName() : TEXT("No World"));
  96.         GWorld = PlayWorld;
  97.         GIsPlayInEditorWorld = true;
  98.        
  99.         // Remember Simulating flag so that we know if OnSimulateSessionFinished is required after everything has been cleaned up.
  100.         bool bWasSimulatingInEditor = PlayInEditorSessionInfo->OriginalRequestParams.WorldType == EPlaySessionWorldType::SimulateInEditor;
  101.        
  102.         //重置音频   --------------------------------------------------------- [不需要]
  103.         // Stop all audio and remove references to temp level.
  104.         if (FAudioDevice* AudioDevice = PlayWorld->GetAudioDeviceRaw())
  105.         {
  106.                 AudioDevice->Flush(PlayWorld);
  107.                 AudioDevice->ResetInterpolation();
  108.                 AudioDevice->OnEndPIE(false); // TODO: Should this have been bWasSimulatingInEditor?
  109.                 AudioDevice->SetTransientMasterVolume(1.0f);
  110.         }
  112.         //LevelStreaming相关,热重启所在的场景是空场景,不会有LevelStreaming   --- [不需要]
  113.         // Clean up all streaming levels
  114.         PlayWorld->bIsLevelStreamingFrozen = false;
  115.         PlayWorld->SetShouldForceUnloadStreamingLevels(true);
  116.         PlayWorld->FlushLevelStreaming();
  118.         //LevelStreaming相关,热重启所在的场景是空场景,不会有LevelStreaming   --- [不需要]
  119.         // cleanup refs to any duplicated streaming levels
  120.         for ( int32 LevelIndex=0; LevelIndex<PlayWorld->GetStreamingLevels().Num(); LevelIndex++ )
  121.         {
  122.                 ULevelStreaming* StreamingLevel = PlayWorld->GetStreamingLevels()[LevelIndex];
  123.                 if( StreamingLevel != NULL )
  124.                 {
  125.                         const ULevel* PlayWorldLevel = StreamingLevel->GetLoadedLevel();
  126.                         if ( PlayWorldLevel != NULL )
  127.                         {
  128.                                 UWorld* World = Cast<UWorld>( PlayWorldLevel->GetOuter() );
  129.                                 if( World != NULL )
  130.                                 {
  131.                                         // Attempt to move blueprint debugging references back to the editor world
  132.                                         if( EditorWorld != NULL && EditorWorld->GetStreamingLevels().IsValidIndex(LevelIndex) )
  133.                                         {
  134.                                                 const ULevel* EditorWorldLevel = EditorWorld->GetStreamingLevels()[LevelIndex]->GetLoadedLevel();
  135.                                                 if ( EditorWorldLevel != NULL )
  136.                                                 {
  137.                                                         UWorld* SublevelEditorWorld  = Cast<UWorld>(EditorWorldLevel->GetOuter());
  138.                                                         if( SublevelEditorWorld != NULL )
  139.                                                         {
  140.                                                                 World->TransferBlueprintDebugReferences(SublevelEditorWorld);
  141.                                                         }       
  142.                                                 }
  143.                                         }
  144.                                 }
  145.                         }
  146.                 }
  147.         }
  149.         //Editor相关   -------------------------------- [不需要]
  150.         // Construct a list of editors that are active for objects being debugged. We will refresh these when we have cleaned up to ensure no invalid objects exist in them
  151.         TArray< IBlueprintEditor* > Editors;
  152.         UAssetEditorSubsystem* AssetEditorSubsystem = GEditor->GetEditorSubsystem<UAssetEditorSubsystem>();
  153.         const UWorld::FBlueprintToDebuggedObjectMap& EditDebugObjectsPre = PlayWorld->GetBlueprintObjectsBeingDebugged();
  154.         for (UWorld::FBlueprintToDebuggedObjectMap::TConstIterator EditIt(EditDebugObjectsPre); EditIt; ++EditIt)
  155.         {
  156.                 if (UBlueprint* TargetBP = EditIt.Key().Get())
  157.                 {
  158.                         if(IBlueprintEditor* EachEditor = static_cast<IBlueprintEditor*>(AssetEditorSubsystem->FindEditorForAsset(TargetBP, false)))
  159.                         {
  160.                                 Editors.AddUnique( EachEditor );
  161.                         }
  162.                 }
  163.         }
  165.         //通知Actor即将销毁,热重启场景是一个稳定的空场景,不存在需要销毁的Actor  ----- [不需要]
  166.         // Go through and let all the PlayWorld Actor's know they are being destroyed
  167.         for (FActorIterator ActorIt(PlayWorld); ActorIt; ++ActorIt)
  168.         {
  169.                 ActorIt->RouteEndPlay(EEndPlayReason::EndPlayInEditor);
  170.         }
  171.    
  172.         //GameInstance::Shutdown     ---------------- [需要]
  173.         PieWorldContext.OwningGameInstance->Shutdown();
  175.         //Editor相关     --------- [不需要]
  176.         // Move blueprint debugging pointers back to the objects in the editor world
  177.         PlayWorld->TransferBlueprintDebugReferences(EditorWorld);
  179.         //物理系统的虚拟场景清理,由于我们不会清理当前场景   ----  [不需要]
  180.         FPhysScene* PhysScene = PlayWorld->GetPhysicsScene();
  181.         if (PhysScene)
  182.         {
  183.                 PhysScene->WaitPhysScenes();
  184.                 PhysScene->KillVisualDebugger();
  185.         }
  187.         //清理场景,热重启的空场景不需要清理    ------  [不需要]
  188.         // Clean up the temporary play level.
  189.         PlayWorld->CleanupWorld();
  190.         // Remove from root (Seamless travel may have done this)
  191.         PlayWorld->RemoveFromRoot();
  192.         PlayWorld = NULL;
  193.    
  194.          //Editor相关 ---------------------------------------------------------------[不需要]
  195.         // Refresh any editors we had open in case they referenced objects that no longer exist.
  196.         for (int32 iEditors = 0; iEditors <  Editors.Num(); iEditors++)
  197.         {
  198.                 Editors[ iEditors ]->RefreshEditors();
  199.         }
  200.        
  201.         // Restore GWorld.
  202.         GWorld = EditorWorld;
  203.         GIsPlayInEditorWorld = false;
  205.         FWorldContext& EditorWorldContext = GEditor->GetEditorWorldContext();
  207.         //依然是清理Viewport,不需要清理Viewport      -------- [不需要]
  208.         // Let the viewport know about leaving PIE/Simulate session. Do it after everything's been cleaned up
  209.         // as the viewport will play exit sound here and this has to be done after GetAudioDevice()->Flush
  210.         // otherwise all sounds will be immediately stopped.
  211.         if (!PieWorldContext.RunAsDedicated)
  212.         {
  213.                 // Slate data for this pie world
  214.                 FSlatePlayInEditorInfo* const SlatePlayInEditorSession = SlatePlayInEditorMap.Find(PieWorldContext.ContextHandle);
  215.                 if (SlatePlayInEditorSession && SlatePlayInEditorSession->DestinationSlateViewport.IsValid())
  216.                 {
  217.                         TSharedPtr<IAssetViewport> Viewport = SlatePlayInEditorSession->DestinationSlateViewport.Pin();
  219.                         if( Viewport->HasPlayInEditorViewport() )
  220.                         {
  221.                                 Viewport->EndPlayInEditorSession();
  222.                         }
  224.                         // Let the Slate viewport know that we're leaving Simulate mode
  225.                         if( bWasSimulatingInEditor )
  226.                         {
  227.                                 Viewport->OnSimulateSessionFinished();
  228.                         }
  230.                         StaticCast<FLevelEditorViewportClient&>(Viewport->GetAssetViewportClient()).SetReferenceToWorldContext(EditorWorldContext);
  231.                 }
  233.                 // Remove the slate info from the map (note that the UWorld* is long gone at this point, but the WorldContext still exists. It will be removed outside of this function)
  234.                 SlatePlayInEditorMap.Remove(PieWorldContext.ContextHandle);
  235.         }
  236. }
复制代码
看来TeardownPlaySession中只有OwningGameInstance->Shutdown();是我们关心的。


最终总结一下,模拟PIE的Stop流程中需要注意的只有两个调用:
1.FlushAsyncLoading().
2.OwningGameInstance->Shutdown();
而FlushAsyncLoading()是阻塞加载所有异步请求没什么好说的,我们就主要看看UGameInstance::Shutdown()
-------------------------------"怎么来的" 结束分割线----------------------------------------
"怎么做呢":
让我们来看看UGameInstance::Shutdown()：
注意看中文注释(忽略误选中的选中框)
再对比一下UGameInstance::Init()
注意看中文注释(忽略误选中的选中框)
对比:
Shutdown:Init:
1.通知蓝图Shutdown1.通知蓝图Init
2.清理网络回话对象2.创建网络回话对象
3.清理所有LocalPlayer3.XXXXXXXXXXXXX
4.清理所有GameInstanceSubsystem4.初始化所有GameInstanceSubsystem
5.清理网路错误委托监听5.绑定网络错误委托监听
6.清理WorldContext6.XXXXXXXXXXXX
可见，Shutdown相对Init多了：清理所有LocalPlayer，清理WorldContext。什么概念呢? 就是Shutdown做了些事情，而且是在再次Init后都没办法恢复。
1.清理LocalPlayer: LocalPlayer代表一个用户端,一般手游都是只有一个LocalPlayer,主机游戏可能会通过分屏方式出现两个或者四个LocalPlayer。清理LocalPlayer后如果不进行恢复,用户端的输入将无效,包括Console Command.
2.清理WorldContext: WorldContext即是World上下文,与UWorld有关系,并且会影响到一些需要区别多个LocalPlayer的接口.
这个时候,有人可能会问"既然是模拟Shutdown，是不是可以直接把Shutdown逻辑拷贝一下就行?"，当然这也是一个办法。但是每个项目都会继承UGameInstance，那每层继承都要拷贝，修改的时候还要注意修改两处，维护起来是很麻烦。所以使用UGameInstance的Shutdown和Init会更方便维护。
下面是模拟逻辑ShutdownOnlyForReload和InitOnlyForReload，最终都会调用到Shutdown和Init.
  1. void UMGameInstance::ShutdownOnlyForReload()
  2. {
  3.         UE_LOG(LogTemp,Log,TEXT("UMGameInstance::ShutdownOnlyForReload....Start"));
  5.         FWorldContext* WorldContextOld = WorldContext;  //记录一下WorldContext,Shutdown中置空后再复制回去即可.
  7.         Shutdown();                              //调用UMGameInstance::Shutdown,在里面还会进行UnLua释放
  8.        
  9.         GameInstance = this;
  10.         WorldContext = WorldContextOld;          //还原WorldContext
  12.         FString OutError;
  13.         CreateInitialPlayer(OutError);                  //恢复LocalPlayer
  15.         UE_LOG(LogTemp,Log,TEXT("UMGameInstance::ShutdownOnlyForReload....End"));
  16. }
  18. void UMGameInstance::InitOnlyForReload()
  19. {
  20.         UE_LOG(LogTemp,Log,TEXT("UMGameInstance::InitOnlyForReload....Start"));
  21.        
  22.         Init();                                  //调用UMGameInstance::Init
  23.        
  24.         FBasicMainEntry::InitLua(GetWorld());      //初始化Lua.
  25.        
  26.         UE_LOG(LogTemp,Log,TEXT("UMGameInstance::InitOnlyForReload....End"));
  27. }
复制代码

"怎么验证"
1.Lua: Shutdown过程会把Lua_State释放，所以Lua里的数据Cache和UObject引用都会释放掉了.
2.非UObject实例/静态实例: 这里并没有验证方法，但是文章开头就说了，模拟PIE的Stop&Play流程，开发阶段就要保证重复Stop&Play能正常运作的，这是很正常的项目规范要求。加上非UObject实例/静态对象都不会影响UObject的GC。而回归到需求，只是进行资源重新加载，所以不需要保证这些对象都被清理干净，只需要保证重复Stop&Play正常工作即可。
3.UObject实例: 在Shutdown和UnMount所有资源后,中止重启流程,遍历打印所有的UObject，并人肉检查UObject的释放情况。遍历打印代码如下:
  1. //bNeedClass 是否显示Class并参与排序
  2. //bNoReflectionObj 是否不收集UFunction/UClass/UStruct这些UObject
  3. //bOnlyContent 是否只打印工程资源.
  4. void DumpAllObj(bool bNeedClass,bool bNoReflectionObj,bool bOnlyContent)
  5. {
  6.         TArray<FString> strObjs;
  7.         for (TObjectIterator<UObject> It; It; ++It)
  8.         {
  9.                 UObject* Obj = *It;
  10.                
  11.                 if (!bNoReflectionObj || (Cast<UField>(Obj) == nullptr
  12. #if ENGINE_MINOR_VERSION < 25
  13.                         && Cast<UProperty>(Obj) == nullptr
  14. #endif
  15.                         && Cast<UFunction>(Obj) == nullptr
  16.                         && Cast<UClass>(Obj) == nullptr
  17.                         && Cast<UStruct>(Obj) == nullptr))
  18.                 {
  19.                         if (!bOnlyContent || (Obj->GetPathName().StartsWith("/Game/")))
  20.                         {
  21.                                 if (bNeedClass)
  22.                                         strObjs.Add(Obj->GetFullName());
  23.                                 else
  24.                                         strObjs.Add(Obj->GetPathName());
  25.                         }
  26.                 }
  27.         }
  29.         strObjs.Sort();
  31.         FString DumpLogFile = FString::Format(TEXT("{0}/DumpAllObj_{1}_{2}_{3}.txt"), { FPaths::ConvertRelativePathToFull(FPaths::ProjectPersistentDownloadDir()),bNeedClass,bNoReflectionObj,bOnlyContent });
  32.         FFileHelper::SaveStringArrayToFile(strObjs, *DumpLogFile, FFileHelper::EEncodingOptions::ForceUTF8);
  33. }
复制代码

"怎么解决":
验证后，发现问题该怎么解决呢?
非UObject问题: 主要是通过项目规范进行约束。
UObject问题: 可能会打印出来上万个没有正常释放的UObject，如果逐一人肉排查引用关系，是很恐怖的事。这里有个小经验，可以先从引用集合UObject开始排查，像DataTable和DataAsset，因为UObject会带来很多引用，释放掉DataTable，UObject数量能大幅度减少。
查找引用代码：
  1. void PrintAllReferencers(FString ObjName)
  2. {
  3.         TMap<UObject*,FObjReferencers> AllReferencers = GetAllReferencers(ObjName);
  5.         UE_LOG(LogTemp,Log,TEXT("---------Start Print All References of %s"),*ObjName);
  6.        
  7.         for(TMap<UObject*,FObjReferencers>::TIterator Iter = AllReferencers.CreateIterator();Iter;++Iter)
  8.         {
  9.                 UObject* ReferenceeObj = Iter->Key;
  10.                 UE_LOG(LogTemp,Log,TEXT("Referencers Of %s (%s):"),*(ReferenceeObj->GetFName().ToString()),*(ReferenceeObj->GetClass()->GetFName().ToString()));
  12.                 FObjReferencers ReferencersInfo = Iter->Value;
  13.                 for(TArray<UObject*>::TIterator Iter2 = ReferencersInfo.Referencers.CreateIterator();Iter2;++Iter2)
  14.                 {
  15.                         UObject* ReferencerObj =  *Iter2;
  16.                         UE_LOG(LogTemp,Log,TEXT("%30s (%s)"),*(ReferencerObj->GetFName().ToString()),*(ReferencerObj->GetClass()->GetFName().ToString()));
  17.                 }
  19.                 UE_LOG(LogTemp,Log,TEXT("--------------------------"));
  20.         }
  22.         UE_LOG(LogTemp,Log,TEXT("---------End Print All References of %s"),*ObjName);
  23. }
复制代码

--------------------------------------------------------------------------------------------
这个方案已经在项目里使用，为了增加测试的机会，我把游戏账号登出也改成了重启XD。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

×
回复

使用道具 举报

返回列表 发新帖
懒得打字嘛，点击右侧快捷回复 【右侧内容，后台自定义】
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Unity开发者联盟 ( 粤ICP备20003399号 )

GMT+8, 2024-11-26 00:25 , Processed in 0.095346 second(s), 26 queries .

Powered by Discuz! X3.5 Licensed

© 2001-2024 Discuz! Team.

快速回复 返回顶部 返回列表