循迹研究室

Unreal Engine

Unreal Engine is the best 3D Game Engine!

GIST NOTES

注意：使用GIST管理的笔记，在国内网络可能会无法显示。

WaitForDebugger

可以让引擎启动前等待调试器Aattach，避免因为附加的时机导致没法调试引擎的部分：LaunchEngineLoop.cpp#L542

1
2
3
4
5
6
7
8
// If "-WaitForDebugger" was specified, halt startup and wait for a debugger to attach before continuing
if( FParse::Param( FCommandLine::Get(), TEXT( "WaitForDebugger" ) ) )
{
    while( !FPlatformMisc::IsDebuggerPresent() )
    {
        FPlatformProcess::Sleep( 0.1f );
    }
}

DDC的初始化栈

从DDC获取已编译的Shader

调用栈如下：

会尝试从项目的Boot、引擎的/Engine/DerivedDataCache中加载：

会去DDC目录下查找对应的文件：

如果CacheKey的文件有找到，则命中了DDC缓存，如未找到，则需要重新编译该Shader。

DDC的存储：
当用代码等待Shader编译完毕，会触发DDC的存储：

1
2
3
4
5
6
while(GShaderCompilingManager->IsCompiling())
{
  GShaderCompilingManager->ProcessAsyncResults(false, false);
  UE_LOG(LogHotPatcher,Display,TEXT("Remaining Shader %d"),GShaderCompilingManager->GetNumRemainingJobs())
  FPlatformProcess::Sleep(0.5f);
}

调用栈：

DDC的存储，是通过异步线程来存盘的，会先存储为一个诸如L”../../../Engine/DerivedDataCache/8/0/4/temp.D77B47384C075959597A3B9EB38B84BF”的临时文件，然后再重命名到真正的CacheKey路径。

存储结果：

Shader编译流程

材质实例也会造成Shader的编译：

如果母材质定义了很多开关，材质实例里不同的参数会导致运行不同的shader代码，造成shader编译。

比如植被的shader，树叶要开启alphaclip和double side，树干不需要。但是要看shader里是怎么写的，是用宏来区分，还是用变量。是宏的话是运行不同的shader代码，变量的话是同一份shader.

如果材质实例的变动改变了获取的ShaderMapId，则需要编译出一个新的Shader：

其他的介绍文章：UE4 Shader 编译以及变种实现

并行Cook的Crash

在开启并行Cook时，对于部分资源会触发断言，产生Crash：


栈往前翻翻发现是某个地图的贴图：

调试后发现是Landscape在BeginCacheForCookedPlatformData时生成的一个UTexture对象：

并且没有给它生成PlatformData。

若不开启并行Cook，则没有问题，在Cook时会给它们生成PlatformData，但是开启并行Cook流程就不一样了：

  1. 需要在主线程先给所有的Package生成PlatformData
  2. 在并行Cook时，不能在非主线程生成PlatformData

所以就会触发上面的断言，在主线程之外执行了。

解决办法是，在生成这些UTexture时就给它们生成PlatformData并等待Cache完成：

Engine\Source\Runtime\Landscape\Private\Landscape.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
{
  // for parallel cooking
  TArray<UTexture2D*> MobileWeightmapTexturesCopy = MobileWeightmapTextures;
  for(auto& MobileWeightmapTexture:MobileWeightmapTexturesCopy)
  {
    MobileWeightmapTexture->BeginCacheForCookedPlatformData(TargetPlatform);
  }
        
  while(MobileWeightmapTexturesCopy.Num())
  {
    for(int32 ExportObjIndex = MobileWeightmapTexturesCopy.Num() - 1 ;ExportObjIndex >= 0;--ExportObjIndex)
    {
      if (MobileWeightmapTexturesCopy[ExportObjIndex]->IsCachedCookedPlatformDataLoaded(TargetPlatform))
      {
        MobileWeightmapTexturesCopy.RemoveAtSwap(ExportObjIndex,1,false);
      }
    }
    if(!!MobileWeightmapTexturesCopy.Num())
    {
        FPlatformProcess::Sleep(0.001f);
    }
  }
}

Cook时控制StaticMesh的LOD级别

StaticMesh.cpp中定义了两个CVars，可以控制：

1
2
3
4
5
6
7
8
9
10
static TAutoConsoleVariable<int32> CVarStripMinLodDataDuringCooking(
        TEXT("r.StaticMesh.StripMinLodDataDuringCooking"),
        0,
        TEXT("If non-zero, data for Static Mesh LOD levels below MinLOD will be discarded at cook time"));

int32 GForceStripMeshAdjacencyDataDuringCooking = 0;
static FAutoConsoleVariableRef CVarForceStripMeshAdjacencyDataDuringCooking(
        TEXT("r.ForceStripAdjacencyDataDuringCooking"),
        GForceStripMeshAdjacencyDataDuringCooking,
        TEXT("If set, adjacency data will be stripped for all static and skeletal meshes during cooking (acting like the target platform did not support tessellation)."));

AssetRegistry的数据源

AssetRegistry的数据是从uasset文件中读取到的，可以调用AssetRegistry模块进行扫描：

1
AssetRegistryModule.Get().ScanFilesSynchronous(paths, true);

4.26-引擎在Commandlet中开启Tick的Crash问题

因为FSlateApplication在Commandlet中初始化导致的，但我们又不需要，所以将获取FSlateApplication的地方进行检测即可：

Engine\Source\Editor\UnrealEd\Private\AssetThumbnail.cpp
1
2
3
4
5
6
7
8
9
void FAssetThumbnailPool::Tick( float DeltaTime )
{
        // If throttling do not tick unless drag dropping which could have a thumbnail as the cursor decorator
        if (FSlateApplication::IsInitialized() && !FSlateApplication::Get().IsDragDropping() && !FSlateThrottleManager::Get().IsAllowingExpensiveTasks() && !FSlateApplication::Get().AnyMenusVisible())
        {
                return;
   }
  // ...
}

以及：

Engine\Source\Editor\UnrealEd\Private\EditorEngine.cpp
1
2
3
4
5
6
7
8
bool UEditorEngine::AreAllWindowsHidden() const
{
        if(!FSlateApplication::IsInitialized())
        {
                return true;
        }
        // ...
}

官方代码在4.26开始就已经修复了。

蓝图函数参数结构的Slate定制化

如FGamePlayTag在蓝图参数中的节点：

其实现是在FGameplayTagsGraphPanelPinFactory中：

在FGameplayTagsEditorModule里注册到EdGraphUtilities里的。

Engine\Plugins\Editor\GameplayTagsEditor\Source\GameplayTagsEditor\Private\GameplayTagsEditorModule.cpp
1
2
TSharedPtr<FGameplayTagsGraphPanelPinFactory> GameplayTagsGraphPanelPinFactory = MakeShareable(new FGameplayTagsGraphPanelPinFactory());
FEdGraphUtilities::RegisterVisualPinFactory(GameplayTagsGraphPanelPinFactory);

Post-Processing

启用插件:CustomShaderUE

在代码中执行：

1
2
3
4
// .h
TSharedPtr<FCustomViewExtension,ESPMode::ThreadSafe> CustomViewExtension;
// .cpp
CustomViewExtension = FSceneViewExtensions::NewExtension<FCustomViewExtension>(FLinearColor::Green);

包体大小优化指南

Cook World栈

在Cook World类型的资源时，会调用UEditorEngine::InitializePhysicsSceneForSaveIfNecessary，进而会调用World的UpdateWorldComponents，具体栈如下：

LongPackageNameToFileName

将/Game/XXX转换为资源的磁盘路径：

StaticMesh没有碰撞导致的Cook失败

1
2
LogPhysics: Warning: Failed to cook convex: /Game/Assets/Environment/SM_XZCQYIS_Tree001_c.SM_XZCQYIS_Tree001_c 0 (FlipX:0). The remaining elements will not get cooked.
LogPhysicsCore: Error: PHYSX: (D:\Build\++Fortnite\Sync\Engine\Source\ThirdParty\PhysX3\PhysX_3.4\Source\PhysXCooking\src\Cooking.cpp 198) eINVALID_PARAMETER : Cooking::cookConvexMesh: user-provided convex mesh descriptor is invalid!

检查模型是否有简单和复杂碰撞，若没有添加一个即可。

Android命令行启动UE APP

1
adb shell am start com.tencent.tmgp.fmgame/com.epicgames.ue4.GameActivity

android指定启动参数的方法

Source\Runtime\Launch\Private\Android\LaunchAndroid.cpp
1
static void InitCommandLine()
  1. 指定ue4commandline.txt，移动端指定启动参数。
  2. 通过AndroidConfigRuleSystem，安卓配置规则系统，它在GameActivity.java.template#L1579中被读取，并通过JNI调用(Java_com_epicgames_ue4_GameActivity_nativeSetConfigRulesVariables)传递给引擎C++侧，最终在InitCommandLine中获取，并追加到引擎的命令行参数。
Launch/Private/Android/LaunchAndroid.cpp
1
2
3
4
5
if (FString* ConfigRulesCmdLineAppend = FAndroidMisc::GetConfigRulesVariable(TEXT("cmdline")))
{
    FCommandLine::Append(**ConfigRulesCmdLineAppend);
    FPlatformMisc::LowLevelOutputDebugStringf(TEXT("ConfigRules appended: %s"), **ConfigRulesCmdLineAppend);
}
  1. setprop，通过adb设置一个名为debug.ue4.commandline的prop，将参数填入其中，会被追加到启动参数里（4.26+）。
1
2
3
4
5
6
7
8
9
10
// Name of the UE4 commandline append setprop
static constexpr char UE4CommandLineSetprop[] = "debug.ue4.commandline";

char CommandLineSetpropAppend[CMD_LINE_MAX];
if (__system_property_get(UE4CommandLineSetprop, CommandLineSetpropAppend) > 0)
{
    FCommandLine::Append(UTF8_TO_TCHAR(" "));
    FCommandLine::Append(UTF8_TO_TCHAR(CommandLineSetpropAppend));
    FPlatformMisc::LowLevelOutputDebugStringf(TEXT("UE4 setprop appended: %s"), UTF8_TO_TCHAR(CommandLineSetpropAppend));
}
1
2
adb shell setprop debug.ue4.commandline '-test123'
adb shell am start com.tencent.tmgp.fmgame/com.epicgames.ue4.GameActivity

如果开启了启动时的LaunchImage：

1
2
bool bShowLaunchImage = false;
Ini.GetBool("/Script/AndroidRuntimeSettings.AndroidRuntimeSettings", "bShowLaunchImage", out bShowLaunchImage);

则启动的Activity则就从com.epicgames.ue4.GameActivity变成了com.epicgames.ue4.SplashActivity。

给游戏传递参数：

1
adb shell am start -a android.intent.action.MAIN -n com.imzlp.gworld/com.epicgames.ue4.GameActivity --es cmdline xxxx

定义外部可用的全局符号

有时候，在插件或者其他的模块中，想要定义一个全局对象，供内部或者外部的模块访问，就像UE内置的GEngine/GConfig这些。

首先需要把C++中声明和定义的概念区分开，我之前有篇文章介绍：C++ 中 declaration 与 define 的区别。

因为我们想要访问的全局对象，应该只有一个实例，而不是每个使用模块都包含了一个定义的实例，所以只应该在有一个定义，其他模块引用时只是一个声明，声明它在外部模块中定义，应该去其他模块中访问该实例。

以Windows为例，UE的模块，会编译成DLL，如果我们想要访问某个模块的符号，就是要访问它的DLL中的符号。在UE中，导出符号使用XXXX_API封装，同样在之前的笔记中有记录：

以A、B两个模块为例：A_API在A模块中被定义为DLLEXPORT，在B模块中被定义为DLLIMPORT，所以，A中使用A_API定义一个符号，会控制它编译出的A.dll中该符号导出，在外部模块B中使用该符号时，就是导入。

理解起来或许有点绕，以代码来理解：

1
2
3
4
5
6
7
// A.h
extern A_API int32* GTestPtr; // declare a external pointer symbal
// extern DLLEXPORT int32* GTestPtr = nullptr;

// A.cpp
A_API int32* GTestPtr = nullptr; // define the global symbal
// DLLEXPORT int32* GTestPtr = nullptr;

在B中访问它：

1
2
3
4
// B.cpp
#include "A.h"

if(GTestPtr){}

在B中包含A.h，在B中，A.h中的extern A_API int32* GTestPtr;就变成了以下代码：

1
extern DLLIMPORT int32* GTestPtr;

在编译B模块时，DLLIMPORT会指导链接器(linker)去外部的模块查找该符号，从而实现在B中访问A中定义的全局对象。

错误用法1：

1
2
3
4
// A.h
int32* GTestPtr;
// A.cpp
int* GTestPtr = NULL;

如果在A中这么声明，在B中访问GTestPtr则会有符号未定义的链接错误。

错误用法2：

1
2
// A.h
static int32* GTestPtr;

则每个包含A.h的翻译单元都包含了一个GTestPtr的符号实例，并不是全局唯一的。

修改StaticMesh的CollisionPreset

UStaticMesh->UBodySetup->FBodyInstance->CollisionProfileName。

CollisionProfileName在BodyInstanceCustomization.cpp中创建了自定义的属性面板：

Editor\DetailCustomizations\Private\BodyInstanceCustomization.cpp
1
void FBodyInstanceCustomization::AddCollisionCategory(TSharedRef<class IPropertyHandle> StructPropertyHandle, class IDetailChildrenBuilder& StructBuilder, IPropertyTypeCustomizationUtils& StructCustomizationUtils);

Commandlet启动时不编译shader

启动时添加NoShaderCompile参数。

1
2
* To disable shader compiling during the run of the commandlet add "-NoShaderCompile" to the commandline.
* This would be added as data member setting except that the shader compiler is initialized before a commandlet is created so it cannot be queried soon enough.

Android运行时修改Icon

4.27- Xcode13编译错误

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
UATHelper: Packaging (iOS):     error: The Legacy Build System will be removed in a future release. You can configure the selected build system and this deprecation message in File > Workspace Settings.
UATHelper: Packaging (iOS):     Build Preparation
UATHelper: Packaging (iOS):     The Legacy Build System will be removed in a future release. You can configure the selected build system and this deprecation message in File > Workspace Settings.
UATHelper: Packaging (iOS):   
UATHelper: Packaging (iOS):     ** BUILD FAILED **
UATHelper: Packaging (iOS):   
UATHelper: Packaging (iOS):   
UATHelper: Packaging (iOS):     The following build commands failed:
UATHelper: Packaging (iOS):        Prepare build
UATHelper: Packaging (iOS):     (1 failure)
UATHelper: Packaging (iOS):     Executing /Users/lipengzha/UE4/Builds/LIPENGZHA-PC/D/UnrealProjects/Blank426/Intermediate/Build/IOS/Blank426/Development/CleanProject.sh
PackagingResults: Error: The Legacy Build System will be removed in a future release. You can configure the selected build system and this deprecation message in File > Workspace Settings.
UATHelper: Packaging (iOS):     ERROR: Unhandled exception: System.Exception: ** BUILD FAILED **
UATHelper: Packaging (iOS):              at UnrealBuildTool.IOSToolChain.PostBuildSync (UnrealBuildTool.IOSPostBuildSyncTarget Target) [0x00cad] in <1849fe2d2cfe48d9910e4d9444acc602>:0
UATHelper: Packaging (iOS):              at UnrealBuildTool.IOSPostBuildSyncMode.Execute (Tools.DotNETCommon.CommandLineArguments Arguments) [0x00018] in <1849fe2d2cfe48d9910e4d9444acc602>:0
UATHelper: Packaging (iOS):              at UnrealBuildTool.UnrealBuildTool.Main (System.String[] ArgumentsArray) [0x002bb] in <1849fe2d2cfe48d9910e4d9444acc602>:0
PackagingResults: Error: Unhandled exception: System.Exception: ** BUILD FAILED **

4.27中已修复这个问题：

打包Windows窗口化

Saved/Config/WindowsNoEditor/GameUserSettings.ini
1
2
3
4
5
6
[/Script/Engine.GameUserSettings]
bUseVSync=False
ResolutionSizeX=960
ResolutionSizeY=540
LastUserConfirmedResolutionSizeX=960
LastUserConfirmedResolutionSizeY=540

也可以添加到DefaultGameUserSettings.ini里。

启动时加-Windowed参数。

UE-Docker

Primary Asset Types标记的资产扫描

在UAssetManager::ScanPathsForPrimaryAssets中，在AssetRegistry加载之后：

它会根据Primary Asset Types构造出一个AssetRegistry.GetAssets(ARFilter, AssetDataList);的调用，扫描标记的路径和资产类型。

将其添加到PrimaryAssetType对应的资源列表中。

通过ModifyCook调用时会检查PrimaryAsset的配置：

Engine\Source\Runtime\Engine\Private\AssetManager.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// UAssetManager::ModifyCook(TArray<FName>& PackagesToCook, TArray<FName>& PackagesToNeverCook)
for (FName PackageName : AssetPackages)
{
    EPrimaryAssetCookRule CookRule = GetPackageCookRule(PackageName);

    // Treat DevAlwaysCook as AlwaysCook, may get excluded in VerifyCanCookPackage
    bool bAlwaysCook = (CookRule == EPrimaryAssetCookRule::AlwaysCook || CookRule == EPrimaryAssetCookRule::DevelopmentAlwaysCook);
    bool bCanCook = VerifyCanCookPackage(PackageName, false);

    if (bAlwaysCook && bCanCook && !TypeInfo.bIsEditorOnly)
    {
        // If this is always cook, not excluded, and not editor only, cook it
        PackagesToCook.AddUnique(PackageName);
    }
    else if (!bCanCook)
    {
        // If this package cannot be cooked, add to exclusion list
        PackagesToNeverCook.AddUnique(PackageName);
    }
}

只有标记为AlwayCook或者DevelopmentAlwayCook，并且它管理的资源并不是EditorOnly的情况下，才会将其管理的资源添加到Cook列表中。

Rider 配置

修改Rider的JVM配置

修改Rider的Rider64.vmoptions修改JVM虚拟机的配置：

Rider64.vmoptions
1
2
3
4
-Xms1024m
-Xmx50000m
-XX:ReservedCodeCacheSize=1024m
-XX:+UseStringDeduplication
  • Xms和Xmx是调整Java堆内存的最小值和最大值，调大了不容易gc
  • ReservedCodeCacheSize是调整编译代码缓存大小
  • UseStringDeduplication：开启后Java也支持像Lua那样全局共用相同的字符串，节省内存。

项目缓存路径

1
C:\Users\lipengzha\AppData\Local\JetBrains\Rider2021.2\resharper-host\local\Transient\Rider\v212\SolutionCaches

Editor Preferences配置

源码版引擎在Engine\Engine\Saved\Config\Windows\EditorSettings.ini文件中。

UE游戏安全与逆向分析

GlobalShaderCache*.bin

默认打包时会在Saved/Cooked/PLATFORM_NAME/Engine/目录下创建GlobalShaderCache*.bin文件。

它是在SaveGlobalShaderFile中存储的：

Engine\Private\ShaderCompiler\ShaderCompiler.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/** Saves the global shader map as a file for the target platform. */
FString SaveGlobalShaderFile(EShaderPlatform Platform, FString SavePath, class ITargetPlatform* TargetPlatform)
{
    FGlobalShaderMap* GlobalShaderMap = GetGlobalShaderMap(Platform);

    // Wait until all global shaders are compiled
    if (GShaderCompilingManager)
    {
        GShaderCompilingManager->ProcessAsyncResults(false, true);
    }

    TArray<uint8> GlobalShaderData;
    {
        FMemoryWriter MemoryWriter(GlobalShaderData, true);
        if (TargetPlatform)
        {
            MemoryWriter.SetCookingTarget(TargetPlatform);
        }
        GlobalShaderMap->SaveToGlobalArchive(MemoryWriter);
    }

    // make the final name
    FString FullPath = SavePath / GetGlobalShaderCacheFilename(Platform);
    if (!FFileHelper::SaveArrayToFile(GlobalShaderData, *FullPath))
    {
        UE_LOG(LogShaders, Fatal, TEXT("Could not save global shader file to '%s'"), *FullPath);
    }

#if WITH_EDITOR
    if (FShaderCodeLibrary::NeedsShaderStableKeys(Platform))
    {
        GlobalShaderMap->SaveShaderStableKeys(Platform);
    }
#endif // WITH_EDITOR
    return FullPath;
}

它由RecompileShadersForRemote调用，在CookOnTheFlyServer的SaveGlobalShaderMapFiles中被执行。

Primary Asset Types to Scan

打包时要扫描的主要资产类型。可以理解为，他们管理了一堆资源，在打包时会将他们添加到打包列表中。

以引擎默认添加的Map和PrimaryAssetLabel为例：

  • Map：会扫描/Game/Maps下的所有地图，将它们添加到Cook列表中。
  • PrimaryAssetLabel：会扫描/Game下的所有PrimaryAssetLabel类型的资产，将其中指定的资源添加（或忽略）到Cook列表中。

如果两个PrimaryAssetLabel同时管理了某个资源，如A和B两个Primary管理了不同的地图，它们都依赖了一个资源C，而A和B的CookRule以及优先级不同，在ModiyCook中会产生获取Cook规则的错误：

1
2
3
4
5
6
7
8
9
10
11
12
13
LogInit: Display: LogAssetManager: Error: GetPackageCookRule: Conflicting Cook Rule for package /Engine/EngineMaterials/WeightMapPlaceholderTexture! PrimaryAssetLabel:OpenWorldMaps and PrimaryAssetLabel:HoudiniTest_hysl_eastern have the same priority and disagree.
LogInit: Display: LogAssetManager: Error: GetPackageCookRule: Conflicting Cook Rule for package /Engine/EngineMaterials/DefaultPhysicalMaterial! PrimaryAssetLabel:OpenWorldMaps and PrimaryAssetLabel:HoudiniTest_hysl_eastern have the same priority and disagree.
LogInit: Display: LogAssetManager: Error: GetPackageCookRule: Conflicting Cook Rule for package /Engine/Functions/Engine_MaterialFunctions02/Texturing/WorldPositionWithScale! PrimaryAssetLabel:OpenWorldMaps and PrimaryAssetLabel:Fb_ThePoolOfTribute_02_Main have the same priority and disagree.
LogInit: Display: LogAssetManager: Error: GetPackageCookRule: Conflicting Cook Rule for package /Engine/Functions/Engine_MaterialFunctions02/SafeNormalize! PrimaryAssetLabel:OpenWorldMaps and PrimaryAssetLabel:HoudiniTest_hysl_eastern have the same priority and disagree.
LogInit: Display: LogAssetManager: Error: GetPackageCookRule: Conflicting Cook Rule for package /Engine/Functions/Engine_MaterialFunctions02/Utility/BreakOutFloat4Components! PrimaryAssetLabel:OpenWorldMaps and PrimaryAssetLabel:Fb_ThePoolOfTribute_02_Main have the same priority and disagree.
LogInit: Display: LogAssetManager: Error: GetPackageCookRule: Conflicting Cook Rule for package /Engine/Functions/Engine_MaterialFunctions02/WorldPositionOffset/ObjectScale! PrimaryAssetLabel:OpenWorldMaps and PrimaryAssetLabel:HoudiniTest_hysl_eastern have the same priority and disagree.
LogInit: Display: LogAssetManager: Error: GetPackageCookRule: Conflicting Cook Rule for package /Engine/Functions/Engine_MaterialFunctions02/FixRotateAboutAxisNormals! PrimaryAssetLabel:OpenWorldMaps and PrimaryAssetLabel:HoudiniTest_hysl_eastern have the same priority and disagree.
LogInit: Display: LogAssetManager: Error: GetPackageCookRule: Conflicting Cook Rule for package /Engine/Functions/Engine_MaterialFunctions02/Utility/LinearSine! PrimaryAssetLabel:OpenWorldMaps and PrimaryAssetLabel:HoudiniTest_hysl_eastern have the same priority and disagree.
LogInit: Display: LogAssetManager: Error: GetPackageCookRule: Conflicting Cook Rule for package /Engine/Functions/Engine_MaterialFunctions02/SmoothThreshold! PrimaryAssetLabel:OpenWorldMaps and PrimaryAssetLabel:HoudiniTest_hysl_eastern have the same priority and disagree.
LogInit: Display: LogAssetManager: Error: GetPackageCookRule: Conflicting Cook Rule for package /Engine/Functions/Engine_MaterialFunctions02/PivotPainter/TreeAnimationSines! PrimaryAssetLabel:OpenWorldMaps and PrimaryAssetLabel:HoudiniTest_hysl_eastern have the same priority and disagree.
LogInit: Display: LogAssetManager: Error: GetPackageCookRule: Conflicting Cook Rule for package /Engine/Functions/Engine_MaterialFunctions02/WorldPositionOffset/Wind! PrimaryAssetLabel:OpenWorldMaps and PrimaryAssetLabel:HoudiniTest_hysl_eastern have the same priority and disagree.
LogInit: Display: LogAssetManager: Error: GetPackageCookRule: Conflicting Cook Rule for package /Engine/Functions/Engine_MaterialFunctions02/Math/AddComponents! PrimaryAssetLabel:OpenWorldMaps and PrimaryAssetLabel:HoudiniTest_hysl_eastern have the same priority and disagree.
LogInit: Display: LogAssetManager: Error: GetPackageCookRule: Conflicting Cook Rule for package /Engine/Functions/Engine_MaterialFunctions02/PivotPainter/PivotPainter_TreeData! PrimaryAssetLabel:OpenWorldMaps and PrimaryAssetLabel:HoudiniTest_hysl_eastern have the same priority and disagree.

Windows编译Metal Shader的栈

在ShaderCodeLibrary::PackageNativeShaderLibrary中调用了CreateShaderArchive:

Runtime\RenderCore\Private\ShaderCodeLibrary.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
bool PackageNativeShaderLibrary(const FString& ShaderCodeDir)
{
    if (SerializedShaders.GetNumShaders() == 0)
    {
        return true;
    }

    FString IntermediateFormatPath = GetShaderDebugFolder(FPaths::ProjectSavedDir() / TEXT("Shaders") / FormatName.ToString(), LibraryName, FormatName);
    FString TempPath = IntermediateFormatPath / TEXT("NativeLibrary");

    IFileManager::Get().MakeDirectory(*TempPath, true);
    IFileManager::Get().MakeDirectory(*ShaderCodeDir, true);

    EShaderPlatform Platform = ShaderFormatToLegacyShaderPlatform(FormatName);
    const bool bOK = Format->CreateShaderArchive(LibraryName, FormatName, TempPath, ShaderCodeDir, IntermediateFormatPath, SerializedShaders, ShaderCode, nullptr);
    if (bOK)
    {
        // Delete Shader code library / pipelines as we now have native versions
        {
            FString OutputFilePath = GetCodeArchiveFilename(ShaderCodeDir, LibraryName, FormatName);
            IFileManager::Get().Delete(*OutputFilePath);
        }
        {
            FString OutputFilePath = GetPipelinesArchiveFilename(ShaderCodeDir, LibraryName, FormatName);
            IFileManager::Get().Delete(*OutputFilePath);
        }
    }

    // Clean up the saved directory of temporary files
    IFileManager::Get().DeleteDirectory(*IntermediateFormatPath, false, true);
    IFileManager::Get().DeleteDirectory(*TempPath, false, true);

    return bOK;
}

在Metal的ShaderPlatform，会调用到Source\Developer\Apple\MetalShaderFormat\Private\MetalShaderFormat.cpp中的实现。其中有获取Metal工具链编译Shader的代码。

Cook时进程的性能配置

在CookOnTheFlyServer.cpp的UCookOnTheFlyServer::Initialize中，读取Ini配置，设置编译Shader的任务数、最大并行shader任务数、内存分配等。

Commandlet禁用渲染线程

添加-norenderthread参数：GenericPlatformMisc.cpp#L1144

1
2
3
4
5
6
7
8
9
bool FGenericPlatformMisc::UseRenderThread()
{
    // look for disabling commandline options (-onethread is old-school, here for compatibility with people's brains)
    if (FParse::Param(FCommandLine::Get(), TEXT("norenderthread")) || FParse::Param(FCommandLine::Get(), TEXT("onethread")))
    {
        return false;
    }
  // ...
}

Shader编译配置

DevOptions.Shaders：

默认情况下会创建系统线程数-3个编译Shader的进程。

如4核八线程会创建出5个ShaderCompileWorker进程。

UnrealPak的加密参数

UnrealPak支持的命令行参数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
LogPakFile: Display: Using command line for crypto configuration
LogPakFile: Error: No pak file name specified. Usage:
LogPakFile: Error:   UnrealPak <PakFilename> -Test
LogPakFile: Error:   UnrealPak <PakFilename> -List [-ExcludeDeleted]
LogPakFile: Error:   UnrealPak <PakFilename> <GameUProjectName> <GameFolderName> -ExportDependencies=<OutputFileBase> -NoAssetRegistryCache -ForceDependsGathering
LogPakFile: Error:   UnrealPak <PakFilename> -Extract <ExtractDir> [-Filter=<filename>]
LogPakFile: Error:   UnrealPak <PakFilename> -Create=<ResponseFile> [Options]
LogPakFile: Error:   UnrealPak <PakFilename> -Dest=<MountPoint>
LogPakFile: Error:   UnrealPak <PakFilename> -Repack [-Output=Path] [-ExcludeDeleted] [Options]
LogPakFile: Error:   UnrealPak <PakFilename1> <PakFilename2> -diff
LogPakFile: Error:   UnrealPak <PakFolder> -AuditFiles [-OnlyDeleted] [-CSV=<filename>] [-order=<OrderingFile>] [-SortByOrdering]
LogPakFile: Error:   UnrealPak <PakFilename> -WhatsAtOffset [offset1] [offset2] [offset3] [...]
LogPakFile: Error:   UnrealPak <PakFolder> -GeneratePIXMappingFile -OutputPath=<Path>
LogPakFile: Error:   Options:
LogPakFile: Error:     -blocksize=<BlockSize>
LogPakFile: Error:     -bitwindow=<BitWindow>
LogPakFile: Error:     -compress
LogPakFile: Error:     -encrypt
LogPakFile: Error:     -order=<OrderingFile>
LogPakFile: Error:     -diff (requires 2 filenames first)
LogPakFile: Error:     -enginedir (specify engine dir for when using ini encryption configs)
LogPakFile: Error:     -projectdir (specify project dir for when using ini encryption configs)
LogPakFile: Error:     -encryptionini (specify ini base name to gather encryption settings from)
LogPakFile: Error:     -extracttomountpoint (Extract to mount point path of pak file)
LogPakFile: Error:     -encryptindex (encrypt the pak file index, making it unusable in unrealpak without supplying the key)
LogPakFile: Error:     -compressionformat[s]=<Format[,format2,...]> (set the format(s) to compress with, falling back on failures)
LogPakFile: Error:     -encryptionkeyoverrideguid (override the encryption key guid used for encrypting data in this pak file)
LogPakFile: Error:     -sign (generate a signature (.sig) file alongside the pak)
LogPakFile: Error:     -fallbackOrderForNonUassetFiles (if order is not specified for ubulk/uexp files, figure out implicit order based on the uasset order. Generally applies only to the cooker order)
LogPakFile: Display: Unreal pak executed in 0.006367 seconds

关于包的加密，在Project Settings-Crypto中有四个选项：

  • bEnablePakIndexEncryption:加密Pakindex
  • bEnablePakIniEncryption：加密pak中的ini
  • bEnablePakUAssetEncryption：加密pak中的uasset
  • bEnablePakFullAssetEncryption：加密Pak中所有的文件

但是除了bEnablePakIndexEncryption之外，其他的参数并不是传递给UnrealPak的命令行参数，而是生成的Paklist中每个文件的参数：

对paklist中的对应格式文件添加-encrypt参数。

1
2
3
4
5
"C:\Users\lipengzha\Documents\UnrealProjects\Blank425\Saved\Cooked\WindowsNoEditor\Engine\Content\EngineResources\GradientTexture0.uasset" "../../../Engine/Content/EngineResources/GradientTexture0.uasset" -encrypt
"C:\Users\lipengzha\Documents\UnrealProjects\Blank425\Saved\Cooked\WindowsNoEditor\Engine\Content\EngineResources\GradientTexture0.uexp" "../../../Engine/Content/EngineResources/GradientTexture0.uexp" -encrypt
"C:\Users\lipengzha\Documents\UnrealProjects\Blank425\Saved\Temp\Win64\Engine\Config\Base.ini" "../../../Engine/Config/Base.ini" -encrypt
"C:\Users\lipengzha\Documents\UnrealProjects\Blank425\Saved\Temp\Win64\Engine\Config\BaseCompat.ini" "../../../Engine/Config/BaseCompat.ini" -encrypt
"C:\Users\lipengzha\Documents\UnrealProjects\Blank425\Intermediate\Staging\Blank425.upluginmanifest" "../../../Blank425/Plugins/Blank425.upluginmanifest" -encrypt

当开启了bEnablePakIniEncryption，就会对当前Paklist中的ini文件添加-encrypt参数。

获取私有UObject类属性的方法

以UCryptoKeysSettings为例，它在Classes/CryptoKeysSettings.h中定义，外部模块无法访问，但是可以用FindObject绕过：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
UClass* Class = FindObject<UClass>(ANY_PACKAGE, TEXT("/Script/CryptoKeys.CryptoKeysSettings"), true);
if(Class)
{
    FString AESKey;
    for(TFieldIterator<FProperty> PropertyIter(Class);PropertyIter;++PropertyIter)
    {
    FProperty* PropertyIns = *PropertyIter;
    if(PropertyIns->GetName().Equals(ENCRYPT_KEY_NAME))
    {
        AESKey = *PropertyIns->ContainerPtrToValuePtr<FString>(Class->GetDefaultObject());
    }
    }
    if(!AESKey.IsEmpty())
    {
    Result += FString::Printf(TEXT("-aes=\"%s\" "),*AESKey);
    }
}

引擎内的图片资源

定义在Engine\Source\Editor\EditorStyle\Private\SlateEditorStyle.cpp路径下。

使用：

1
2
SNew(SImage)
.Image(FEditorStyle::GetBrush("LauncherCommand.QuickLaunch"))

构建插件

1
Engine\Build\BatchFiles\RunUAT.bat BuildPlugin -Plugin=[Path to .uplugin file, must be outside engine directory] -Package=[Output directory] -Rocket

加载资源到磁盘文件读取栈

加载/Engine/Functions/Engine_MaterialFunctions02/Utility/DebugScalarValues资源，最终从磁盘读取的调用栈：

把PackagePath转换为UFS路径的栈：

通过IFileManager::Get().CreateFileReader()抽象接口调用到具体的平台相关的PlatformFile：

IFileManager::Get().CreateFileReader实际上是通过调用GetLowLevel()获取到IPlatformFile的:

1
2
3
4
FORCEINLINE IPlatformFile& GetLowLevel() const
{
	return FPlatformFileManager::Get().GetPlatformFile();
}

通过FPlatformFileManager::Get().SetPlatformFile即可切换不同的PlatformFile。

从而实现从磁盘或者从Pak中文件的IO.

关闭Rider扫描uasset

默认打包UI目录

LongPackageNameToFilename

FPackageName::LongPackageNameToFilename可以将/Game/UI等路径转换为物理相对路径。

多进程Cook

可以给CookCommand传递-numcookerstospawn=参数，指定想要启动的Cooker数量。

Cook时的资源收集

Editor/UnrealEd/Private/CookOnTheFlyServer.cpp
1
2
void UCookOnTheFlyServer::CollectFilesToCook(TArray<FName>& FilesInPath, const TArray<FString>& CookMaps, const TArray<FString>& InCookDirectories,
	const TArray<FString> &IniMapSections, ECookByTheBookOptions FilesToCookFlags, const TArrayView<const ITargetPlatform* const>& TargetPlatforms)

在打包时也会收集已经被加载到内存中的包：

1
2
3
4
/**
* Get any packages which are in memory, these were probably required to be loaded because of the current package we are cooking, so we should probably cook them also
*/
TArray<UPackage*> GetUnsolicitedPackages(const TArray<const ITargetPlatform*>& TargetPlatforms) const;

在引擎的PreInitPostStartupScreen阶段启动，并会持续收集Cook过程中创建的资源并执行Cook。
可以添加一个在PostEngineInit阶段启动的Module获取，与Commandlet执行时相同。

编译UBlueprint

UBlueprint是所有蓝图（包含动画蓝图、Object/Actor/Component蓝图），动画蓝图是UAnimBlueprint。

1
2
/** Tries to compile a blueprint, updating any actors in the editor who are using the old class, etc... */
static void FKismetEditorUtilities::CompileBlueprint(UBlueprint* BlueprintObj, EBlueprintCompileOptions CompileFlags = EBlueprintCompileOptions::None, class FCompilerResultsLog* pResults = nullptr );

从编译的结果可以获取UBlueprint是否具有警告或错误。

IOS Metal Shader or HLSL Shader

对于IOS包，加载metal还是ushaderbytecode的逻辑：

  1. 尝试加载metalib，若加载失败，则FMetalDynamicRHI::RHICreateShaderLibrary返回nullptr (Apple\MetalRHI\Private\MetalShaders.cpp)
  2. 加载metalib失败，则加载ushaderbytecode

看原理上来说，也支持基础包是metalib+热更的ushaderbytecode，以及反之。

Runtime\RenderCore\Private\ShaderCodeLibrary.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class FShaderLibraryInstance
{
public:
	static FShaderLibraryInstance* Create(EShaderPlatform InShaderPlatform, const FString& ShaderCodeDir, FString const& InLibraryName)
	{
		FRHIShaderLibraryRef Library;
		if (RHISupportsNativeShaderLibraries(InShaderPlatform))
		{
			Library = RHICreateShaderLibrary(InShaderPlatform, ShaderCodeDir, InLibraryName);
		}

		if (!Library)
		{
          	const FName PlatformName = LegacyShaderPlatformToShaderFormat(InShaderPlatform);
			const FString DestFilePath = GetCodeArchiveFilename(ShaderCodeDir, InLibraryName, PlatformName);
			TUniquePtr<FArchive> Ar(IFileManager::Get().CreateFileReader(*DestFilePath));
          	//...
        }
      // ...
    }
};

UE4.27官方支持Docker

NVIDIA的UE仓库

Android不支持ApexDestruction

在Engine\Plugins\Runtime\ApexDestruction\Source\ThirdParty\PhysX\ApexDestructionLib.Build.cs中，没有添加移动平台的链接库。

并且，Programs\UnrealBuildTool\Platform\Android\UEBuildAndroid.cs中，强制关掉了bCompileApex：

Programs\UnrealBuildTool\Platform\Android\UEBuildAndroid.cs
1
2
3
4
5
6
7
8
9
public override void ValidateTarget(TargetRules Target)
{
    Target.bCompilePhysX = true;
    Target.bCompileAPEX = false;
    Target.bCompileNvCloth = false;

    Target.bCompileRecast = true;
    Target.bCompileISPC = false;
}

UDataTable限定结构类型

通过UPROPERTY中加meta的RequiredAssetDataTags即可实现：

1
2
UPROPERTY(EditAnywhere, Category=Appearance, meta = (RequiredAssetDataTags = "RowStructure=RichImageRow"))
class UDataTable* ImageSet;

从DataTable中加载数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// .h
UPROPERTY(EditAnywhere,Category="RulesTable", meta=(RequiredAssetDataTags = "RowStructure=ScannerMatchRule"))
TSoftObjectPtr<class UDataTable> ImportRulesTable;

// .cpp
{
    UDataTable* RulesTable = ImportRulesTable.Get();
    TArray<FName> RowNames = RulesTable->GetRowNames();
    FString ContextString;
    for (auto& name : RowNames)
    {
        FScannerMatchRule* pRow = RulesTable->FindRow<FScannerMatchRule>(name, ContextString);
        ScannerRules.Add(*pRow);
    }
}

从关卡的UObject获取AWorldsettings

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
bool ULevelMapRule::Match_Implementation(UObject* Object, const FString& AssetType)
{
    bool bIsMatch = false;
    UWorld *World = Cast<UWorld>(Object);
    if (World)
    {
        AWorldSettings*  Settings = World->GetWorldSettings();
        if (Settings)
        {
            TSubclassOf<class AGameModeBase> GameMode = Settings->DefaultGameMode;
            if (!GameMode || (GameMode && GameMode->GetName().Equals(TEXT("NetGameMode"))))
                bIsMatch = true;
            UE_LOG(LogTemp, Log, TEXT("Map %s Game Mode is %s"), *World->GetMapName(),*GameMode->GetPathName());
        }
    }
    return !bIsMatch;
}

adb执行console command

1
$ adb shell am broadcast -a android.intent.action.RUN -e cmd ""

如果是在shell中，只需要指定am及之后的命令即可。实际上这也是UE中Android平台实现的ExecuteConsoleCommand的方式：

Engine\Source\Developer\Android\AndroidTargetPlatform\Private\AndroidTargetDevice.inl
1
2
3
4
5
inline void FAndroidTargetDevice::ExecuteConsoleCommand(const FString& ExecCommand) const
{
    FString AdbCommand = FString::Printf(TEXT("shell \"am broadcast -a android.intent.action.RUN -e cmd '%s'\""), *ExecCommand);
    ExecuteAdbCommand(AdbCommand, nullptr, nullptr);
}

获取当前运行的Ini平台名

如WindowsNoEditor/WindowsClient/WindowsServer使用的均是Config/Windows/下的配置文件，可以通过以下方法获取配置平台名字。

1
ANSI_TO_TCHAR(FPlatformProperties::IniPlatformName())

ImportText

FProperty具有ImportText函数，可以从字符串中导入数据，第一个参数是值字符串，第二个参数是接收值的对象，可以通过ContainerPtrToValuePtr获取。

1
2
3
4
5
6
7
8
9
const TCHAR* ImportText( const TCHAR* Buffer, void* Data, int32 PortFlags, UObject* OwnerObject, FOutputDevice* ErrorText = (FOutputDevice*)GWarn ) const
    {
        if ( !ValidateImportFlags(PortFlags,ErrorText) || Buffer == NULL )
        {
            return NULL;
        }
        PortFlags |= EPropertyPortFlags::PPF_UseDeprecatedProperties; // Imports should always process deprecated properties
        return ImportText_Internal( Buffer, Data, PortFlags, OwnerObject, ErrorText );
    }

使用方法：

1
2
3
4
5
if (Property->ImportText(*Value, Property->ContainerPtrToValuePtr<uint8>(this, i), PortFlags, this) == NULL)
{
    // this should be an error as the properties from the .ini / .int file are not correctly being read in and probably are affecting things in subtle ways
    UE_LOG(LogObj, Error, TEXT("LoadConfig (%s): import failed for %s in: %s"), *GetPathName(), *Property->GetName(), *Value);
}

需要考虑Array和非Array的情况，使用以下方法遍历：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
FArrayProperty* Array = CastField<FArrayProperty>( Property );
if( Array == NULL )
{
    for( int32 i=0; i<Property->ArrayDim; i++ )
    {
        if( Property->ArrayDim!=1 )
        {
            Key = FString::Printf(TEXT("%s[%i]"), *Property->GetName(), i);
        }
        if (Property->ImportText(*Value, Property->ContainerPtrToValuePtr<uint8>(this, i), PortFlags, this) == NULL)
        {
            // this should be an error as the properties from the .ini / .int file are not correctly being read in and probably are affecting things in subtle ways
            UE_LOG(LogObj, Error, TEXT("LoadConfig (%s): import failed for %s in: %s"), *GetPathName(), *Property->GetName(), *Value);
        }
    }
}

UE截图Graph的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
#include "Slate/WidgetRenderer.h"
#include "Engine/TextureRenderTarget2D.h"
#include "Misc/ScopedSlowTask.h"
#include "ImageUtils.h"
#include "Misc/FileHelper.h"
#include "EdGraphNode_Comment.h"
#include "GraphEditor/Private/SGraphEditorImpl.h"
#include "GraphEditor/Public/SGraphPanel.h"
#include "GraphEditor/Public/SNodePanel.h"
#include "SNotificationList.h"
#include "NotificationManager.h"

#ifndef PRIVATEACCESS_MEMBER
#define PRIVATEACCESS_MEMBER(Class, Member, ...)                                                    \
    namespace PrivateAccess                                                                         \
    {                                                                                               \
        using MemberPtr##Class##Member##Type = __VA_ARGS__;                                         \
        using MemberPtr##Class##Member = MemberPtr##Class##Member##Type Class::*;                   \
        template<MemberPtr##Class##Member MemPtr>                                                   \
        struct Get##Class##Member                                                                   \
        {                                                                                           \
            friend MemberPtr##Class##Member Access##Class##Member() { return MemPtr; }              \
        };                                                                                          \
        MemberPtr##Class##Member Access##Class##Member();                                           \
        template struct Get##Class##Member<&##Class::##Member>;                                     \
        auto& Member(const Class& obj) { return const_cast<Class&>(obj).*Access##Class##Member(); } \
        auto& Member(const Class* obj) { return Member(*obj); }                                     \
    }
#endif

PRIVATEACCESS_MEMBER(SGraphEditorImpl, GraphPanel, TSharedPtr<SGraphPanel>)
PRIVATEACCESS_MEMBER(SNodePanel, NodeToWidgetLookup, TMap<UObject*, TSharedRef<SNodePanel::SNode>>)
PRIVATEACCESS_MEMBER(SNodePanel, ViewOffset, FVector2D)

void Capture(TSharedPtr<SGraphEditor> GraphEditor)
{
    do
    {
        SGraphEditorImpl* Impl = static_cast<SGraphEditorImpl*>(GraphEditor.Get());
        if(!ensure(Impl))
            break;
        TSharedPtr<SGraphPanel> GraphPanel = PrivateAccess::GraphPanel(Impl);
        if (!ensure(GraphPanel.IsValid()))
            break;
        SNodePanel* NodePanel = static_cast<SNodePanel*>(GraphPanel.Get());
        if (!ensure(NodePanel))
            break;

        FScopedSlowTask SlowTask(1.0f, LOCTEXT("Capture", "Capturing Graph"));
        SlowTask.MakeDialog(false);

        TSharedPtr<FWidgetRenderer> Render = MakeShareable(new FWidgetRenderer(true));
        static const FName BpEditorModuleName("Kismet");
        auto& NodeToWidgetLookup = PrivateAccess::NodeToWidgetLookup(NodePanel);
        FVector2D MinCorner = FVector2D(MAX_FLT, MAX_FLT);
        FVector2D MaxCorner = FVector2D(-MAX_FLT, -MAX_FLT);
        for (auto NodeIt = NodeToWidgetLookup.CreateConstIterator(); NodeIt; ++NodeIt)
        {
            SNodePanel::SNode& Widget = NodeIt.Value().Get();

            const FVector2D Lower = Widget.GetPosition();
            const FVector2D Upper = Lower + Widget.GetDesiredSize();

            MinCorner.X = FMath::Min(MinCorner.X, Lower.X);
            MinCorner.Y = FMath::Min(MinCorner.Y, Lower.Y);
            MaxCorner.X = FMath::Max(MaxCorner.X, Upper.X);
            MaxCorner.Y = FMath::Max(MaxCorner.Y, Upper.Y);
        }

        SlowTask.EnterProgressFrame(0.2f, LOCTEXT("Capture_Step1", "Collecting Graph Info"));
        FSlateRect rect;
        const int32 Offset = 30;
        MinCorner += FVector2D(-2 * Offset, -2 * Offset);
        MaxCorner += FVector2D(Offset, Offset);

        // save offset
        FVector2D& ViewOffset = PrivateAccess::ViewOffset(NodePanel);
        FVector2D OldOffset = ViewOffset;
        ViewOffset = FVector2D(MinCorner.X, MinCorner.Y);

        FVector2D Size = FVector2D(MaxCorner.X - MinCorner.X, MaxCorner.Y - MinCorner.Y);
        float zoom = GraphPanel->GetZoomAmount();
        FIntPoint ActualSize = FIntPoint(uint32(Size.X * zoom), uint32(Size.Y * zoom));
        if (ActualSize.X == 0 || ActualSize.Y == 0)
        {
            return FReply::Handled();
        }

        uint32 MaxDimension = GetMax2DTextureDimension();
        {
            TArray<FColor> CombineBmp;
            CombineBmp.AddUninitialized(ActualSize.X * ActualSize.Y);

            auto combine_row_col = [](TArray<FColor>& Bmp, int32 ActualX, uint32 row, uint32 col, FColor& color) {
                color.A = 255;
                FColor Current = color;
                Bmp[row * ActualX + col] = Current;
            };

            uint32 RemainSizeX = ActualSize.X;
            uint32 RemainSizeY = ActualSize.Y;
            FVector2D OffsetCache = FVector2D(MinCorner.X, MinCorner.Y);

            int32 SpliteNums = ((uint32)(RemainSizeX / MaxDimension) + 1) * ((uint32)(RemainSizeY / MaxDimension) + 1);

            int32 Counts = 0;

            for (uint32 i = 0; i < (uint32)(RemainSizeX / MaxDimension) + 1; ++i)
            {
                for (uint32 j = 0; j < (uint32)(RemainSizeY / MaxDimension) + 1; ++j)
                {
                    uint32 SizeX = (i == (uint32)(RemainSizeX / MaxDimension)) ? (RemainSizeX - MaxDimension * ((uint32)(RemainSizeX / MaxDimension))) : MaxDimension;
                    uint32 SizeY = (j == (uint32)(RemainSizeY / MaxDimension)) ? (RemainSizeY - MaxDimension * ((uint32)(RemainSizeY / MaxDimension))) : MaxDimension;

                    OffsetCache = FVector2D(i * MaxDimension / zoom, j * MaxDimension / zoom) + FVector2D(MinCorner.X, MinCorner.Y);
                    ViewOffset = OffsetCache;
#if 0
                    UTextureRenderTarget2D* RenderTarget = FWidgetRenderer::CreateTargetFor(FVector2D(SizeX, SizeY), TF_Nearest, true);
#else
                    UTextureRenderTarget2D* RenderTarget = NewObject<UTextureRenderTarget2D>();
                    RenderTarget->ClearColor = FLinearColor::Black;
                    RenderTarget->Filter = TF_Nearest;
                    RenderTarget->SRGB = true;
                    RenderTarget->TargetGamma = 2.2;
                    RenderTarget->InitCustomFormat(SizeX, SizeY, PF_B8G8R8A8, true);
                    RenderTarget->UpdateResourceImmediate(true);
#endif
                    Render->DrawWidget(RenderTarget, GraphPanel.ToSharedRef(), 1.0f, FVector2D(SizeX, SizeY), 0.03f);
                    // to avoid missing
                    Render->DrawWidget(RenderTarget, GraphPanel.ToSharedRef(), 1.0f, FVector2D(SizeX, SizeY), 0.03f);

                    FTextureRenderTargetResource* rtResource = RenderTarget->GameThread_GetRenderTargetResource();
                    FReadSurfaceDataFlags readPixelFlags(RCM_UNorm);

                    TArray<FColor> outBMP;
                    outBMP.AddUninitialized(RenderTarget->GetSurfaceWidth() * RenderTarget->GetSurfaceHeight());
                    rtResource->ReadPixels(outBMP, readPixelFlags);

                    for (uint32 col = 0; col < SizeX; ++col)
                    {
                        for (uint32 row = 0; row < SizeY; ++row)
                        {
                            combine_row_col(CombineBmp, ActualSize.X, j * MaxDimension + row, i * MaxDimension + col, outBMP[row * SizeX + col]);
                        }
                    }

                    Counts++;
                    SlowTask.EnterProgressFrame(0.6f * (float(Counts) / SpliteNums), FText::Format(LOCTEXT("Capture_Step2", "Spliting Graph {0}/{1}"), Counts, SpliteNums));
                }
            }

            SlowTask.EnterProgressFrame(0.1f, LOCTEXT("Capture_Step3", "Merging Graph Image, Please Wait..."));
            TArray<uint8> CompressedImage;
            FImageUtils::CompressImageArray(ActualSize.X, ActualSize.Y, CombineBmp, CompressedImage);

            FString SaveFileName;

            SaveFileName.Append(FDateTime::Now().ToString());
            SaveFileName.Append(TEXT(".png"));

            FFileHelper::SaveArrayToFile(CompressedImage, *(FPaths::ProjectSavedDir() / SaveFileName));

            ViewOffset = OldOffset;
            SlowTask.EnterProgressFrame(0.1f, LOCTEXT("Capture_Step4", "Finish Capture Graph"));
        }
    } while (0);
}

SwarmAgent alway busy

只有本地工作，远程Agent不工作：

默认情况下SwarmAgent内设置了一个CPU阈值，当最近CPU占用率达到20%，就会从Available变为Busy：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// ...
public partial class Agent : MarshalByRefObject, IAgentInternalInterface, IAgentInterface
{
  //...
  float CPUBusyThreshold = 20.0f;
  // ...
  public void MaintainAgent()
  {
  #if !__MonoCS__
    // We'll only care about this if we're running on a user's machine and assume
    // that on the swarm farm machines, it's the only thing running
    if( ApplicationDeployment.IsNetworkDeployed == false )
  #endif
    {
       // Update the local performance stats
       if( ( LocalPerformanceStats != null ) &&
          ( LocalPerformanceStats.Update() ) )
       {
          // Note that we're quick to become Busy, slow to return to Available
          if( LocalPerformanceStats.LastCPUBusy > CPUBusyThreshold )
          {
            if( CurrentState == AgentState.Available )
            {
               CurrentState = AgentState.Busy;
               PingCoordinator( true );
            }
          }
          else if( LocalPerformanceStats.AverageCPUBusy <= ( CPUBusyThreshold * 0.5f ) )
          {
            if( CurrentState == AgentState.Busy )
            {
               CurrentState = AgentState.Available;
               PingCoordinator( true );
            }
          }
       }
    }
    // ...
  }
 }

FAssetData数据预览

从AssetRegistry获取的AssetData数据，能得到什么信息。
image-20210914163104707

分析UMG的Widget Tree

1
2
3
4
5
6
7
8
9
10
11
FSoftObjectPath AssetObjectPath(PackageName);
UWidgetBlueprint* UserWidgetBlueprint  = Cast<UWidgetBlueprint>(AssetObjectPath.TryLoad());
if(UserWidgetBlueprint)
{
  UWidgetBlueprintGeneratedClass* WBGC = Cast<UWidgetBlueprintGeneratedClass>(UserWidgetBlueprint->GeneratedClass);
  if(WBGC)
  {
   TArray<UWidget*> Widgets;
   WBGC->WidgetTree->GetAllWidgets(Widgets);
  }
}

Share Shader library

UE对Shader的序列化，开启bShareShaderLibrary或使用Inline code的方式序列化。

在开启Share shader library之后也可以开启强制某些材质inline shader code：

1
2
3
[ShaderCodeLibrary]
bEnableInliningWorkaround_Windows=True
+MaterialToInline=/Game/StarterContent/Materials/M_Brick_Clay_Beveled

LOL Binaries Patch

Config的运行时更新

参考UOnlineHotfixManager中的实现：

插件支持Program

1
"SupportedPrograms" : [ "UnrealPak" ],

PackageNativeShaderLibrary

IOS把shaderbytecode编译成metallib。

Pak的拆分生成实现

打包时（执行-run=cook时），会在Saved/Packaging/WindowsNoEditor下生成pakchunklist.txt文件，记录着当前生成的pakchunk的文件名列表：

1
2
3
pakchunk0.txt
pakchunk1.txt
pakchunk2.txt

在当前目录下，会有同名文件，每个文件中记录了当前Pak中应该包含的文件的绝对路径（只包含uasset的资源文件，不包含其他的非UFS文件）：

1
2
3
4
5
6
7
8
9
D:\CompressionLab\Saved\Cooked\WindowsNoEditor\CompressionLab\Content\Mannequin\Animations\ThirdPersonJump_End
D:\CompressionLab\Saved\Cooked\WindowsNoEditor\CompressionLab\Plugins\HDiffPatchUE4\Content\BP_HDiff
D:\CompressionLab\Saved\Cooked\WindowsNoEditor\CompressionLab\Plugins\HDiffPatchUE4\Content\NewMap
D:\CompressionLab\Saved\Cooked\WindowsNoEditor\CompressionLab\Plugins\HDiffPatchUE4\Content\NewMap_BuiltData
D:\CompressionLab\Saved\Cooked\WindowsNoEditor\Engine\Content\Animation\DefaultAnimBoneCompressionSettings
D:\CompressionLab\Saved\Cooked\WindowsNoEditor\Engine\Content\Animation\DefaultAnimCurveCompressionSettings
D:\CompressionLab\Saved\Cooked\WindowsNoEditor\Engine\Content\ArtTools\RenderToTexture\Meshes\S_1_Unit_Plane
D:\CompressionLab\Saved\Cooked\WindowsNoEditor\Engine\Content\BasicShapes\BasicShapeMaterial
D:\CompressionLab\Saved\Cooked\WindowsNoEditor\Engine\Content\BasicShapes\Cone

该文件在bool FAssetRegistryGenerator::GenerateStreamingInstallManifest(AssetRegistryGenerator.cpp)中生成，在CreatePaksUsingChunkManifests(Scripts/CopyBuildToStagingDirectory.Automation.cs)中被使用，它是引擎与UAT打包进行资源信息交互的桥梁。

UE就是通过这种方式实现的Pak拆分，所有的non-UFS文件都默认被打包至0号Chunk，其他的Asset则根据FAssetRegistryGenerator生成的进行Chunk划分。

在执行FAssetRegistryGenerator的流程之后，就会把资源路径存储到对应的pakchunk*.txt中，如果想要手动调用的话需要修改引擎代码，因为FAssetRegistryGenerator没有导出符号，所以不能在外部模块中访问，需要修改引擎添加UNREALED_API导出符号。

然后在自己的模块中包含UnrealEd，使用以下代码即可：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
bool UFlibHotPatcherEditorHelper::GeneratorAssetRegistryData(ITargetPlatform* TargetPlatform, const TSet<FName>& CookedPackageNames, const TSet<FName>& IgnorePackageNames, bool
                                                             bGenerateStreamingInstallManifest)
{
  bool bresult = true;
#if GENERATE_ASSET_REGISTRY_DATA
  TUniquePtr<class FSandboxPlatformFile> TempSandboxFile = MakeUnique<FSandboxPlatformFile>(false);
  TUniquePtr<FAssetRegistryGenerator> RegistryGenerator = MakeUnique<FAssetRegistryGenerator>(TargetPlatform);
  RegistryGenerator->CleanManifestDirectories();
  RegistryGenerator->Initialize(TArray<FName>());
  RegistryGenerator->PreSave(CookedPackageNames);
  RegistryGenerator->BuildChunkManifest(CookedPackageNames, IgnorePackageNames, TempSandboxFile.Get(), bGenerateStreamingInstallManifest);
  bresult = RegistryGenerator->SaveManifests(TempSandboxFile.Get());
#endif
  return bresult;
}

注意需要传入当前执行之前CookedPackageNames，在创建pakchunk*.txt时会根据这个列表里的资源进行分类，也就是说能够实现我们自定义控制的资源列表来根据工程中的PrimaryAssetLabel的Chunk划分来进行分类。

AllChunksInfo.csv

AllChunksInfo.csv是打包时位于Cooked/PLATFORM/PROJECTNAME/Metadata目录下的文件，记录了当前包内资源的Chunk拆分情况。
它在FAssetRegistryGenerator::GenerateAssetChunkInformationCSV中被生成（AssetRegistryGenerator.cpp）。

AES加密

UE具有AES加密的库，加密前后的字节数相同。但需要注意AES加密的数据需要进行16字节对齐。

1
2
3
Result.Bytes.AddZeroed(Align(Result.Bytes.Num(), FAES::AESBlockSize) - Result.Bytes.Num());
FSHA1::HashBuffer(Result.Bytes.GetData(), Result.Bytes.Num(), Info.IndexHash.Hash);
FAES::EncryptData(Result.Bytes.GetData(), Result.Bytes.Num(), InKeyChain.MasterEncryptionKey->Key);

也可以只加密与16字节对齐的大小（忽略余数）。

PakFileRules打包时的文件过滤规则

可以控制某些文件不打包进PAK内。

Scripts/CopyBuildToStagingDirectory.Automation.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
/// <summary>
/// Reads Default/BasePakFileRules.ini and returns all PakFileRules objects that apply for this deployment
/// </summary>
/// <param name="Params"></param>
/// <param name="SC"></param>
private static List<PakFileRules> GetPakFileRules(ProjectParams Params, DeploymentContext SC)
{
  bool bWarnedAboutMultipleTargets = false;
  bool bFoundConfig = false;

  List<ConfigFile> ConfigFiles = new List<ConfigFile>();
  FileReference BaseConfigFileReference = FileReference.Combine(SC.EngineRoot, "Config", "BasePakFileRules.ini");
  if (FileReference.Exists(BaseConfigFileReference))
  {
    ConfigFiles.Add(new ConfigFile(BaseConfigFileReference));
    bFoundConfig = true;
  }

  FileReference ProjectConfigFileReference = FileReference.Combine(SC.ProjectRoot, "Config", "DefaultPakFileRules.ini");
  if (FileReference.Exists(ProjectConfigFileReference))
  {
    ConfigFiles.Add(new ConfigFile(ProjectConfigFileReference));
    bFoundConfig = true;
  }

  if (!bFoundConfig)
  {
    return null;
  }

  bool bChunkedBuild = SC.PlatformUsesChunkManifests && DoesChunkPakManifestExist(Params, SC);

  ConfigHierarchy PakRulesConfig = new ConfigHierarchy(ConfigFiles);

  List<PakFileRules> RulesList = new List<PakFileRules>();
  foreach (string SectionName in PakRulesConfig.SectionNames)
  {
    //LogInformation("Building PakFileRules for Section {0}", SectionName);

    bool bOnlyChunkedBuilds = false;
    if (!PakRulesConfig.TryGetValue(SectionName, "bOnlyChunkedBuilds", out bOnlyChunkedBuilds))
    {
      bOnlyChunkedBuilds = false;
    }

    bool bOnlyNonChunkedBuilds = false;
    if (!PakRulesConfig.TryGetValue(SectionName, "bOnlyNonChunkedBuilds", out bOnlyNonChunkedBuilds))
    {
      bOnlyNonChunkedBuilds = false;
    }

    if (bChunkedBuild && bOnlyNonChunkedBuilds)
    {
      continue;
    }

    if(!bChunkedBuild && bOnlyChunkedBuilds)
    {
      continue;
    }

    string PlatformString;
    if (PakRulesConfig.TryGetValue(SectionName, "Platforms", out PlatformString))
    {
      string[] PlatformStrings = PlatformString.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
      bool bMatches = false;

      // Check platform string
      foreach (string Platform in PlatformStrings)
      {
        if (SC.StageTargetPlatform.PlatformType.ToString().Equals(Platform, StringComparison.OrdinalIgnoreCase))
        {
          bMatches = true;
          break;
        }
        else if (SC.StageTargetPlatform.IniPlatformType.ToString().Equals(Platform, StringComparison.OrdinalIgnoreCase))
        {
          bMatches = true;
          break;
        }
      }

      if (!bMatches)
      {
        //LogInformation("No matching platform for PakFileRules for Section {0} : {1}, {2}", SectionName, SC.StageTargetPlatform.PlatformType.ToString(), SC.StageTargetPlatform.IniPlatformType.ToString());
        continue;
      }
    }

    string TargetString;
    if (PakRulesConfig.TryGetValue(SectionName, "Targets", out TargetString))
    {
      string[] TargetStrings = TargetString.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
      bool bMatches = false;

      // Check target string
      foreach (string Target in TargetStrings)
      {
        foreach (UnrealTargetConfiguration C in SC.StageTargetConfigurations)
        {
          if (C.ToString() == Target)
          {
            bMatches = true;
            break;
          }
        }
      }

      if (!bMatches)
      {
        continue;
      }
      else if (SC.StageTargetConfigurations.Count > 0 && !bWarnedAboutMultipleTargets)
      {
        bWarnedAboutMultipleTargets = true;
        LogInformation("Staging with more than one target, PakFileRules may apply too many rules!");
      }
    }

    PakFileRules PakRules = new PakFileRules();
    PakRules.Name = SectionName;
    PakRulesConfig.TryGetValue(SectionName, "bExcludeFromPaks", out PakRules.bExcludeFromPaks);
    PakRulesConfig.TryGetValue(SectionName, "bOverrideChunkManifest", out PakRules.bOverrideChunkManifest);
    PakRulesConfig.TryGetValue(SectionName, "bDisabled", out PakRules.bDisabled);
    string PakString;
    PakRulesConfig.TryGetValue(SectionName, "OverridePaks", out PakString);

    if (PakString != null && PakString.Length > 0)
    {
      PakRules.OverridePaks = PakString.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
    }
    else
    {
      PakRules.OverridePaks = null;
    }

    if (PakRules.bExcludeFromPaks && PakRules.OverridePaks != null)
    {
      LogWarning("Error in PakFileRules {0}, set to exclude but also sets override!", PakRules.Name);
      continue;
    }
    else if (!PakRules.bExcludeFromPaks && PakRules.OverridePaks == null)
    {
      LogWarning("Error in PakFileRules {0}, set to include but did not specify paks!", PakRules.Name);
      continue;
    }

    IReadOnlyList<string> FilesEnumberable;
    if (PakRulesConfig.TryGetValues(SectionName, "Files", out FilesEnumberable))
    {
      // Only add if we have actual files, we can end up with none due to config overriding
      PakRules.Filter = new FileFilter();
      foreach (string FileFilter in FilesEnumberable)
      {
        //LogInformation("Adding to PakFileRules for Section {0} : {1}", SectionName, FileFilter);
        PakRules.Filter.AddRule(FileFilter);
      }

      RulesList.Add(PakRules);
    }
  }

  return RulesList;
}

Pak的加密

UE对PAK的加密默认为AES，但是也可以自定义加密规则。UE加密的代码为：

Engine/Source/Runtime/PakFile/Private/IPlatformFilePak.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void DecryptData(uint8* InData, uint32 InDataSize, FGuid InEncryptionKeyGuid)
{
  if (FPakPlatformFile::GetPakCustomEncryptionDelegate().IsBound())
  {
    FPakPlatformFile::GetPakCustomEncryptionDelegate().Execute(InData, InDataSize, InEncryptionKeyGuid);
  }
  else
  {
    SCOPE_SECONDS_ACCUMULATOR(STAT_PakCache_DecryptTime);
    FAES::FAESKey Key;
    FPakPlatformFile::GetPakEncryptionKey(Key, InEncryptionKeyGuid);
    check(Key.IsValid());
    FAES::DecryptData(InData, InDataSize, Key);
  }
}

UE的容器化支持

引擎的编辑器设置存储路径

二进制安装版引擎在系统数据目录：

1
C:\Users\lipengzha\AppData\Local\UnrealEngine\4.25\Saved\Config\Windows

源码版引擎在引擎目录：

1
Engine\Engine\Saved\Config\Windows

修改UDP的默认多播端口

引擎默认是6666，可以在Project Settings-Plugins-Networking中修改：

启动UnrealMultiUserServer即可使用变动后的端口：

Cook错误Ensure condition failed: GetSuperClass()

这个错误可能是蓝图循环引用导致的，把循环引用的资源去掉即可。

相关链接：

PakCache的加载

在FPakPlatformFile的OpenAsyncRead中，当启用了GPakCache_Enable，就会创建出一个FPakAsyncReadFileHandle的实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
IAsyncReadFileHandle* FPakPlatformFile::OpenAsyncRead(const TCHAR* Filename)
{
  CSV_SCOPED_TIMING_STAT(FileIO, PakOpenAsyncRead);
//  check(GConfig);
#if USE_PAK_PRECACHE
  if (FPlatformProcess::SupportsMultithreading() && GPakCache_Enable > 0)
  {
    FPakEntry FileEntry;
    FPakFile* PakFile = NULL;
    bool bFoundEntry = FindFileInPakFiles(Filename, &PakFile, &FileEntry);
    if (bFoundEntry && PakFile && PakFile->GetFilenameName() != NAME_None)
    {
#if PAK_TRACKER
      TrackPak(Filename, &FileEntry);
#endif

      return new FPakAsyncReadFileHandle(&FileEntry, PakFile, Filename);
    }
  }
#elif PLATFORM_BYPASS_PAK_PRECACHE
  {
    FPakEntry FileEntry;
    FPakFile* PakFile = NULL;
    bool bFoundEntry = FindFileInPakFiles(Filename, &PakFile, &FileEntry);
    if (bFoundEntry && PakFile && PakFile->GetFilenameName() != NAME_None && FileEntry.CompressionMethodIndex == 0 && !FileEntry.IsEncrypted())
    {
#if PAK_TRACKER
      TrackPak(Filename, &FileEntry);
#endif
      return new FBypassPakAsyncReadFileHandle(&FileEntry, PakFile, Filename);
    }
  }
#endif
  return IPlatformFile::OpenAsyncRead(Filename);
}

这个宏内包裹的就是PakCache处理的代码：

UnreakPak解压指定文件

注意：-Filter的路径是相对于当前Pak的MountPoint的。

如，一个Pak的MountPoint为../../../CompressionLab/Content，则Filter的路径就要相对于它，不能在相对于../../../这种顶级路径，不然会解压失败。

1
UnrealPak.exe -extract ComprtssionLab-WindowsNoEditor.pak D:\Paks -Filter="Engine/Content/EngineMaterials/WorldGridMaterial.*"

替换PakFile的实现

为了实现基于二进制Diff的方案，需要替换掉引擎中默认的PakFile加载实现，需要修改引擎代码：

在工程/插件里实现一个同名的Module即可。

从Pak加载uasset的调用栈

uasset是异步加载的：

HDiff 二进制Patch

1
2
3
4
# Diff
hdiffz.exe OldFile NewFile OutPatchFile
# patch
hpatchz.exe OldFile PatchFile OutNewFile

给资源添加右键菜单处理选项

有些需求，需要在UE的Content Browser里给某些资源添加一些处理功能，希望能直接选中右键进行处理。

UE中提供了这样的方式，用于扩展某种类型资源的右键菜单，需要继承自FAssetTypeActions_Base：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#pragma once
#include "CoreMinimal.h"
#include "Engine/StaticMesh.h"
#include "Toolkits/IToolkitHost.h"
#include "AssetTypeActions_Base.h"
#include "Engine/PrimaryAssetLabel.h"

struct FToolMenuSection;
class FMenuBuilder;

class FAssetTypeActions_PrimaryAssetLabel : public FAssetTypeActions_Base
{
public:
  // IAssetTypeActions Implementation
  virtual FText GetName() const override { return NSLOCTEXT("AssetTypeActions", "AssetTypeActions_PrimaryAssetLabel", "Primary Asset Label"); }
  virtual FColor GetTypeColor() const override { return FColor(0, 255, 255); }
  virtual UClass* GetSupportedClass() const override { return UPrimaryAssetLabel::StaticClass(); }
  virtual bool HasActions( const TArray<UObject*>& InObjects ) const override { return true; }
  virtual void GetActions(const TArray<UObject*>& InObjects, FToolMenuSection& Section) override;
  // virtual void OpenAssetEditor( const TArray<UObject*>& InObjects, TSharedPtr<class IToolkitHost> EditWithinLevelEditor = TSharedPtr<IToolkitHost>() ) override;
  virtual uint32 GetCategories() override { return EAssetTypeCategories::Basic; }
  // virtual class UThumbnailInfo* GetThumbnailInfo(UObject* Asset) const override;
  virtual bool IsImportedAsset() const override { return true; }
  // virtual void GetResolvedSourceFilePaths(const TArray<UObject*>& TypeAssets, TArray<FString>& OutSourceFilePaths) const override;
};

其中最关键的是重写GetSupportedClass返回想要添加到哪种资源的右键菜单里。

.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void FAssetTypeActions_PrimaryAssetLabel::GetActions(const TArray<UObject*>& InObjects,
  FToolMenuSection& Section)
{
  auto Labels = GetTypedWeakObjectPtrs<UPrimaryAssetLabel>(InObjects);
  Section.AddMenuEntry(
  "ObjectContext_AddToPatchIncludeFilters",
  NSLOCTEXT("AssetTypeActions_PrimaryAssetLabel", "ObjectContext_AddToPatchIncludeFilters", "Add To Patch Include Filters"),
  NSLOCTEXT("AssetTypeActions_PrimaryAssetLabel", "ObjectContext_AddToPatchIncludeFiltersTooltip", "Add the label to HotPatcher Include Filters."),
  FSlateIcon(),
  FUIAction(
    FExecuteAction::CreateSP(this, &FAssetTypeActions_PrimaryAssetLabel::ExecuteAddToPatchIncludeFilter, Labels)
  ));
  Section.AddMenuEntry(
      "ObjectContext_AddToChunkConfig",
      NSLOCTEXT("AssetTypeActions_PrimaryAssetLabel", "ObjectContext_AddToChunkConfig", "Add To Chunk Config"),
      NSLOCTEXT("AssetTypeActions_PrimaryAssetLabel", "ObjectContext_AddToChunkConfigTooltip", "Add Label To Chunk Config"),
      FSlateIcon(),
      FUIAction(
        FExecuteAction::CreateSP(this, &FAssetTypeActions_PrimaryAssetLabel::ExecuteAddToChunkConfig, Labels)
      ));
}

在绑定的事件里可以处理对资源的操作流程。

最后，需要把所写的这个类注册到AssetTools里，可以写到Module的StartupModule中：

1
FAssetToolsModule::GetModule().Get().RegisterAssetTypeActions(MakeShareable(new FAssetTypeActions_PrimaryAssetLabel));

效果：

PSO Cache

Runtime/OpenGLDrv/Private/OpenGLShaders.cpp#L2675

C++获取引擎版本

有版本宏定义：

Runtime/Launch/Resources/Version.h
1
2
3
4
// newer than a 4.11.* version, regardless of the changelist that it was built with)
#define ENGINE_MAJOR_VERSION  4
#define ENGINE_MINOR_VERSION  26
#define ENGINE_PATCH_VERSION  2

diff uasset

很久之前我写过一篇在UE中开启版本控制，并Diff资源的操作文章：在UE中使用Git进行版本控制

简单分析一下实现的代码，版本控制右键调用的函数：

Editor/SourceControlWindows/Private/SSourceControlSubmit.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void SSourceControlSubmitWidget::OnDiffAgainstDepotSelected(TSharedPtr<FSubmitItem> InSelectedItem)
{
  FString PackageName;
  if (FPackageName::TryConvertFilenameToLongPackageName(InSelectedItem->GetFileName().ToString(), PackageName))
  {
    TArray<FAssetData> Assets;
    FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
    AssetRegistryModule.Get().GetAssetsByPackageName(*PackageName, Assets);
    if (Assets.Num() == 1)
    {
      const FAssetData& AssetData = Assets[0];
      UObject* CurrentObject = AssetData.GetAsset();
      if (CurrentObject)
      {
        const FString AssetName = AssetData.AssetName.ToString();
        FAssetToolsModule& AssetToolsModule = FModuleManager::GetModuleChecked<FAssetToolsModule>("AssetTools");
        AssetToolsModule.Get().DiffAgainstDepot(CurrentObject, PackageName, AssetName);
      }
    }
  }
}

调用的是AssetTools中的DiffAgainstDepot：

Developer\AssetTools\Private\AssetTools.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
void UAssetToolsImpl::DiffAgainstDepot( UObject* InObject, const FString& InPackagePath, const FString& InPackageName ) const
{
  check( InObject );

  // Make sure our history is up to date
  ISourceControlProvider& SourceControlProvider = ISourceControlModule::Get().GetProvider();
  TSharedRef<FUpdateStatus, ESPMode::ThreadSafe> UpdateStatusOperation = ISourceControlOperation::Create<FUpdateStatus>();
  UpdateStatusOperation->SetUpdateHistory(true);
  SourceControlProvider.Execute(UpdateStatusOperation, SourceControlHelpers::PackageFilename(InPackagePath));

  // Get the SCC state
  FSourceControlStatePtr SourceControlState = SourceControlProvider.GetState(SourceControlHelpers::PackageFilename(InPackagePath), EStateCacheUsage::Use);

  // If we have an asset and its in SCC..
  if( SourceControlState.IsValid() && InObject != nullptr && SourceControlState->IsSourceControlled() )
  {
    // Get the file name of package
    FString RelativeFileName;
    if(FPackageName::DoesPackageExist(InPackagePath, nullptr, &RelativeFileName))
    {
      if(SourceControlState->GetHistorySize() > 0)
      {
        TSharedPtr<ISourceControlRevision, ESPMode::ThreadSafe> Revision = SourceControlState->GetHistoryItem(0);
        check(Revision.IsValid());

        // Get the head revision of this package from source control
        FString AbsoluteFileName = FPaths::ConvertRelativePathToFull(RelativeFileName);
        FString TempFileName;
        if(Revision->Get(TempFileName))
        {
          // Try and load that package
          UPackage* TempPackage = LoadPackage(nullptr, *TempFileName, LOAD_ForDiff|LOAD_DisableCompileOnLoad);
          if(TempPackage != nullptr)
          {
            // Grab the old asset from that old package
            UObject* OldObject = FindObject<UObject>(TempPackage, *InPackageName);
            if(OldObject != nullptr)
            {
              /* Set the revision information*/
              FRevisionInfo OldRevision;
              OldRevision.Changelist = Revision->GetCheckInIdentifier();
              OldRevision.Date = Revision->GetDate();
              OldRevision.Revision = Revision->GetRevision();

              FRevisionInfo NewRevision; 
              NewRevision.Revision = TEXT("");
              DiffAssets(OldObject, InObject, OldRevision, NewRevision);
            }
          }
        }
      }
    } 
  }
}

编辑器中的资源作为新版本，就本本资源从版本库中加载并创建一个临时包，然后进行比对。

Cook图集

Cook图集中项的资源：

Runtime\CoreUObject\Private\UObject\SavePackage.cpp
1
2
3
4
5
6
// Exports got filtered out already if they're not for this platform
if (TagExpObjects.Num() == 0)
{
  UE_CLOG(!(SaveFlags & SAVE_NoError), LogSavePackage, Verbose, TEXT("No exports found (or all exports are editor-only) for %s. Package will not be saved."), *BaseFilename);
  return ESavePackageResult::ContainsEditorOnlyData;
}

No exports found (or all exports are editor-only) for %s. Package will not be saved

STAT GROUP

1
2
3
4
5
6
7
8
9
// .h
DECLARE_STATS_GROUP(TEXT("IMZLP"),STATGROUP_IMZLP,STATCAT_Advanced);

// .cpp
void func()
{ 
  DECLARE_SCOPE_CYCLE_COUNTER(TEXT("test func"), STAT_IMZLP_FUNC, STATGROUP_IMZLP);
  // ...
}

如果出现command not recognised的提示，是因为这个STATGROUP下的CYCLE_COUNTER从来没有被执行过。

离线渲染Sequence命令

在渲染的时候，虚幻引擎提供了基于命令行的接口，用户在命令行中指定项目的路径、地图、Sequencer，以及渲染参数（例如分辨率、质量等）后，虚幻引擎即可离屏渲染出图像。

1
2
3
4
5
6
7
8
9
10
11
UE4Editor.exe
DummyProject.uproject
/Game/NewMap
-game
-MovieSceneCaptureType="/Script/MovieSceneCapture.AutomatedLevelSequenceCapture"
-LevelSequence="/Game/NewLevelSequence"
-MovieFrameRate=30 -noloadingscreen
-resx=1920 -resy=1080 -forceres
-MovieFormat=PNG -MovieQuality=100
-notexturestreaming -MovieCinematicMode=yes
-MovieWarmUpFrames=60 -opengl

输出图像之后，可以使用ffmpeg进行合成，之前有一篇采集的文章：使用 Unreal Engine 4 采集 360° 全景视频

FDebugText

有些需求是在场景中打印不根据透视变化的调试信息，如RecastNavMesh的预览TileLabel：

Runtime\NavigationSystem\Private\NavMesh\NavMeshRenderingComponent.cpp
1
2
3
4
if (bGatherTileLabels)
{
  DebugLabels.Add(FDebugText(NavLocation.Location + NavMeshDrawOffset, FString::Printf(TEXT("(%d,%d:%d)"), X, Y, Layer)));
}

在以下代码中使用：

Runtime\NavigationSystem\Private\NavMesh\NavMeshRenderingComponent.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#if WITH_RECAST && !UE_BUILD_SHIPPING && !UE_BUILD_TEST
void FNavMeshDebugDrawDelegateHelper::RegisterDebugDrawDelgate()
{
  ensureMsgf(State != RegisteredState, TEXT("RegisterDebugDrawDelgate is already Registered!"));
  if (State == InitializedState)
  {
    DebugTextDrawingDelegate = FDebugDrawDelegate::CreateRaw(this, &FNavMeshDebugDrawDelegateHelper::DrawDebugLabels);
    DebugTextDrawingDelegateHandle = UDebugDrawService::Register(TEXT("Navigation"), DebugTextDrawingDelegate);
    State = RegisteredState;
  }
}

void FNavMeshDebugDrawDelegateHelper::UnregisterDebugDrawDelgate()
{
  ensureMsgf(State != InitializedState, TEXT("UnegisterDebugDrawDelgate is in an invalid State: %i !"), State);
  if (State == RegisteredState)
  {
    check(DebugTextDrawingDelegate.IsBound());
    UDebugDrawService::Unregister(DebugTextDrawingDelegateHandle);
    State = InitializedState;
  }
}
#endif
// ...
#if WITH_RECAST && !UE_BUILD_SHIPPING && !UE_BUILD_TEST
void FNavMeshDebugDrawDelegateHelper::DrawDebugLabels(UCanvas* Canvas, APlayerController*)
{
  if (!Canvas)
  {
    return;
  }

  const bool bVisible = (Canvas->SceneView && !!Canvas->SceneView->Family->EngineShowFlags.Navigation) || bForceRendering;
  if (!bVisible || bNeedsNewData || DebugLabels.Num() == 0)
  {
    return;
  }

  const FColor OldDrawColor = Canvas->DrawColor;
  Canvas->SetDrawColor(FColor::White);
  const FSceneView* View = Canvas->SceneView;
  UFont* Font = GEngine->GetSmallFont();
  const FNavMeshSceneProxyData::FDebugText* DebugText = DebugLabels.GetData();
  for (int32 Idx = 0; Idx < DebugLabels.Num(); ++Idx, ++DebugText)
  {
    if (View->ViewFrustum.IntersectSphere(DebugText->Location, 1.0f))
    {
      const FVector ScreenLoc = Canvas->Project(DebugText->Location);
      Canvas->DrawText(Font, DebugText->Text, ScreenLoc.X, ScreenLoc.Y);
    }
  }

  Canvas->SetDrawColor(OldDrawColor);
}
#endif

/Game/Map.Map:PersistentLevel.None

1
2
3
4
5
[2021.06.26-09.08.17:941][518]LogGarbage: Warning: Spent more than 30.00s on routing FinishDestroy to objects (objects in queue: 2)
[2021.06.26-09.08.17:941][518]LogGarbage: Warning:   [0]: SphereComponent /Game/Map.Map:PersistentLevel.None.None, IsReadyForFinishDestroy: false
[2021.06.26-09.08.17:941][518]LogGarbage: Warning:   [1]: SpectatorPawn /Game/Map.Map:PersistentLevel.None, IsReadyForFinishDestroy: false
[2021.06.26-09.08.17:941][518]LogGarbage: Warning: Spent to much time waiting for FinishDestroy for 2 object(s) (last object: SpectatorPawn /Game/Map.Map:PersistentLevel.None), check log for details
[2021.06.26-09.08.17:941][518]LogObj: Warning: UObject::AbortInsideMemberFunction called on object SpectatorPawn /Game/Map.Map:PersistentLevel.None.

出现这个报错是因为场景里有选择一个无效的场景对象：

这种形式的路径引用是选择场景中的对象：

1
/Game/Maps/VFXLight.VFXLight:PersistentLevel.DirectionalLight_1

如果有引用，但是场景中的对象没了，PersistentLevel.DirectionalLight_1这就是一个引用错误，可能会导致Crash。

监听Actor创建事件

可以通过监听UWorld的OnActorSpawned实现：

1
2
3
UWorld* MyWorld = GetWorld();
FOnActorSpawned::FDelegate ActorSpawnedDelegate = FOnActorSpawned::FDelegate::CreateRaw(this, &FWaitForLoadingToFinish::OnActorSpawned);
FDelegateHandle ActorSpawnedDelegateHandle = MyWorld->AddOnActorSpawnedHandler(ActorSpawnedDelegate)

UE4.25字符转换bug

在4.26+中已修复。

Mac用的是2字节的宽字符，但却按4字节的去转，当材质里参数有中文时，就会出现不一致的bug：

Runtime/Core/Private/Serialization/MemoryImage.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
FHashedName::FHashedName(const FName& InName)
{
  if (!InName.IsNone())
  {
    const FNameEntry* Entry = InName.GetComparisonNameEntry();
    const int32 InternalNumber = InName.GetNumber();
    if (Entry->IsWide())
    {
      WIDECHAR WideNameBuffer[NAME_SIZE];
      Entry->GetWideName(WideNameBuffer);
      for (int32 i = 0; i < Entry->GetNameLength(); ++i)
      {
        WideNameBuffer[i] = FCharWide::ToUpper(WideNameBuffer[i]);
      }
            // Bug
            // const FTCHARToUTF8 NameUTF8(WCHAR_TO_TCHAR(WideNameBuffer));
      // Hash = CityHash64WithSeed(NameUTF8.Get(), NameUTF8.Length(), InternalNumber);
          
      // WChar conversion bug in Mac
      if (sizeof(WIDECHAR) != sizeof(TCHAR))
      {
        const FTCHARToUTF8 NameUTF8(WCHAR_TO_TCHAR(WideNameBuffer));
        Hash = CityHash64WithSeed(NameUTF8.Get(), NameUTF8.Length(), InternalNumber);
      }
      else
      {
        const FTCHARToUTF8 NameUTF8((TCHAR*)WideNameBuffer);
        Hash = CityHash64WithSeed(NameUTF8.Get(), NameUTF8.Length(), InternalNumber);
      }
      //
    }
    else
    {
      ANSICHAR AnsiNameBuffer[NAME_SIZE];
      Entry->GetAnsiName(AnsiNameBuffer);
      for (int32 i = 0; i < Entry->GetNameLength(); ++i)
      {
        AnsiNameBuffer[i] = FCharAnsi::ToUpper(AnsiNameBuffer[i]);
      }
      Hash = CityHash64WithSeed(AnsiNameBuffer, Entry->GetNameLength(), InternalNumber);
    }
  }
  else
  {
    Hash = 0u;
  }
}

开启ADDRESS SANITIZER

1
Environment.SetEnvironmentVariable("ENABLE_ADDRESS_SANITIZER", "YES");

监听Cook完成事件

有些操作需要等待Cook的任务完成，可以通过监听UPackage::PackageSavedEvent实现：

1
UPackage::PackageSavedEvent.AddRaw(this,&FCookManager::OnPackageSavedEvent);

使用GEditor->Save进行Cook时即可在回调中监听：

1
2
3
4
5
6
7
8
GIsCookerLoadingPackage = true;
UPackage::PackageSavedEvent.AddLambda([PackageSavedCallback](const FString& InFilePath,UObject* Object){PackageSavedCallback(InFilePath);});
    
// UE_LOG(LogHotPatcherEditorHelper,Display,TEXT("Cook Assets:%s save to %s"),*Package->GetName(),*CookedSavePath);
FSavePackageResultStruct Result = GEditor->Save(Package, nullptr, CookedFlags, *CookedSavePath, 
  GError, nullptr, false, false, SaveFlags, Platform, 
  FDateTime::MinValue(), false, /*DiffMap*/ nullptr,CurrentPlatformPackageContext);
GIsCookerLoadingPackage = false;

地图的最大尺寸

UE中支持的最大World尺寸通过WORLD_MAX宏定义：Runtime/Engine/Public/EngineDefines.h#L27

Source/Runtime/Engine/Public/EngineDefines.h
1
2
3
4
5
6
/*-----------------------------------------------------------------------------
  Size of the world.
-----------------------------------------------------------------------------*/
#define WORLD_MAX         2097152.0       /* Maximum size of the world */
#define HALF_WORLD_MAX        (WORLD_MAX * 0.5)   /* Half the maximum size of the world */
#define HALF_WORLD_MAX1       (HALF_WORLD_MAX - 1.0)  /* Half the maximum size of the world minus one */

超出范围Actor就被销毁了：Runtime/Engine/Private/Components/InterpToMovementComponent.cpp#L394

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
bool UInterpToMovementComponent::CheckStillInWorld()
{
    // ....
  // Check if box has poked outside the world
  else if (UpdatedComponent && UpdatedComponent->IsRegistered())
  {
    const FBox& Box = UpdatedComponent->Bounds.GetBox();
    if (Box.Min.X < -HALF_WORLD_MAX || Box.Max.X > HALF_WORLD_MAX ||
      Box.Min.Y < -HALF_WORLD_MAX || Box.Max.Y > HALF_WORLD_MAX ||
      Box.Min.Z < -HALF_WORLD_MAX || Box.Max.Z > HALF_WORLD_MAX)
    {
      UE_LOG(LogInterpToMovementComponent, Warning, TEXT("%s is outside the world bounds!"), *ActorOwner->GetName());
      ActorOwner->OutsideWorldBounds();
      // not safe to use physics or collision at this point
      ActorOwner->SetActorEnableCollision(false);
      FHitResult Hit(1.f);
      StopSimulating(Hit);
      return false;
    }
  }
    return true;
}

UProperty到FProperty的优化

从4.25开始UProperty正式修改为了FProperty，避免了额外的UProperty的消耗。

官方介绍：

  • Loading performance, especially when loading a large number Blueprints
  • Garbage collection performance, especially when a project has a large number of Blueprints
  • Memory savings, tests in Fortnite show a memory savings of over 30 megabytes.
  • Performance improvements include:
    • UObject iteration (there are fewer objects to check)
    • FProperty casts are three times as fast as UObject casts.
    • FProperty iteration is almost twice as fast as UProperty iteration.

从Target获取编译器版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private static void CheckCompilerVersion(ref string Version, WindowsCompiler Compiler, string LongVersionName, string ShortVersionName)
{
  try
  {
    if (Compiler == (WindowsCompiler)Enum.Parse(typeof(WindowsCompiler), LongVersionName))
    Version = ShortVersionName;
  }
  catch{}
}

private string GetVisualStudioVersion()
{
  string VSVersion = "vc150";
  var Compiler = Target.WindowsPlatform.Compiler;
  CheckCompilerVersion(ref VSVersion, Compiler, "VisualStudio2019", "vc160");
  CheckCompilerVersion(ref VSVersion, Compiler, "VisualStudio2017", "vc150");
  CheckCompilerVersion(ref VSVersion, Compiler, "VisualStudio2015", "vc140");
  CheckCompilerVersion(ref VSVersion, Compiler, "VisualStudio2013", "vc120");
  return VSVersion;
}

Insight Profile Tag in UnLua

可以把SCOPED_NAMED_EVENT封装到Lua端，但是因为Lua没有C++的RAII机制，无法实时地检测离开作用域时机，所以只能通过在起始和结尾位置添加标记：

1
2
3
4
5
function TimerMgr:UpdateTimer(DeltaTime)
    UE4.FScopedNamedEventWrapper.StaticBegin("TimerMgr_UpdateTimer")
    -- dosomething...
    UE4.FScopedNamedEventWrapper.StaticEnd()
end

在C++端的实现：

ScopedNamedEventWrapper.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#pragma once

#include "CoreMinimal.h"
#include "ScopedNamedEventWrapper.generated.h"

USTRUCT()
struct FScopedNamedEventWrapper
{
    GENERATED_BODY()
    
    static void StaticBegin(const FString& Name)
    {
#if PLATFORM_IMPLEMENTS_BeginNamedEventStatic
        FPlatformMisc::BeginNamedEventStatic(FColor::Yellow, *Name);
#else
        FPlatformMisc::BeginNamedEvent(FColor::Yellow, *Name);
#endif
    }

    static void StaticEnd()
    {
        FPlatformMisc::EndNamedEvent();
    }
    bool bInit = false;
};

暴露给Lua端：

Lualib_ScopedNamedEventWrapper.cpp
1
2
3
4
5
6
7
8
9
#include "UnLuaEx.h"
#include "LuaCore.h"
#include "ScopedNamedEventWrapper.h"

BEGIN_EXPORT_REFLECTED_CLASS(FScopedNamedEventWrapper)
    ADD_STATIC_FUNCTION_EX("StaticBegin",void,StaticBegin,const FString&)
    ADD_STATIC_FUNCTION_EX("StaticEnd",void,StaticEnd)
END_EXPORT_CLASS()
IMPLEMENT_EXPORTED_CLASS(FScopedNamedEventWrapper)

然后即可在Lua中使用，并且能够在Unreal Insight中查看Lua端代码执行的消耗：

Insight Profiler Tag

用加标记的形式可以在Unreal Insight或者FrontEnd中对某个作用域进行profiling：

1
2
3
4
5
void func()
{
  SCOPED_NAMED_EVENT(ULuaMgr_Tick, FColor::Yellow);  
  // ...
}

SCOPED_NAMED_EVENT宏其实是在栈上了一个对象。利用C++的RAII机制，当离开作用域时被销毁，从而统计出时间：

Runtime\Core\Public\HAL\PlatformMisc.h
1
2
3
4
5
6
7
8
9
10
11
#define SCOPED_NAMED_EVENT(Name, Color) \
  FScopedNamedEventStatic ANONYMOUS_VARIABLE(NamedEvent_##Name##_)(Color, NAMED_EVENT_STR(#Name));

#define SCOPED_NAMED_EVENT_FSTRING(Text, Color)  FScopedNamedEvent       ANONYMOUS_VARIABLE(NamedEvent_)         (Color, *Text);
#define SCOPED_NAMED_EVENT_TCHAR(Text, Color)    FScopedNamedEvent       ANONYMOUS_VARIABLE(NamedEvent_)         (Color, Text);

#define SCOPED_NAMED_EVENT_TEXT(Text, Color) \
  FScopedNamedEventStatic ANONYMOUS_VARIABLE(NamedEvent_)         (Color, NAMED_EVENT_STR(Text));

#define SCOPED_NAMED_EVENT_F(Format, Color, ...) FScopedNamedEvent       ANONYMOUS_VARIABLE(NamedEvent_)         (Color, *FString::Printf(Format, __VA_ARGS__));
#define SCOPED_PROFILER_COLOR(Color)       FScopedProfilerColor    ANONYMOUS_VARIABLE(ProfilerColor_##Name##_)(Color);

FScopedNamedEventStatic的定义：

Runtime\Core\Public\HAL\PlatformMisc.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//
// Scoped named event class for constant (compile-time) strings literals.
//
// BeginNamedEventStatic works the same as BeginNamedEvent, but should only be passed a compile-time string literal.
// Some platform profilers can optimize the case where strings for certain events are constant.
//
class CORE_API FScopedNamedEventStatic
{
public:

  FScopedNamedEventStatic(const struct FColor& Color, const TCHAR* Text)
  {
#if PLATFORM_IMPLEMENTS_BeginNamedEventStatic
    FPlatformMisc::BeginNamedEventStatic(Color, Text);
#else
    FPlatformMisc::BeginNamedEvent(Color, Text);
#endif
  }

  FScopedNamedEventStatic(const struct FColor& Color, const ANSICHAR* Text)
  {
#if PLATFORM_IMPLEMENTS_BeginNamedEventStatic
    FPlatformMisc::BeginNamedEventStatic(Color, Text);
#else
    FPlatformMisc::BeginNamedEvent(Color, Text);
#endif
  }

  ~FScopedNamedEventStatic()
  {
    FPlatformMisc::EndNamedEvent();
  }
};

Localization Error

IOS加载出现以下错误：

1
No paths for game localization data were specifed in the game configuration.

产生错误的代码为：

Paths.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
const TArray<FString>& FPaths::GetGameLocalizationPaths()
{
  FStaticData& StaticData = TLazySingleton<FStaticData>::Get();
  if(!StaticData.bGameLocalizationPathsInitialized)
  {
    if(GConfig && GConfig->IsReadyForUse())
    {
      GConfig->GetArray( TEXT("Internationalization"), TEXT("LocalizationPaths"), StaticData.GameLocalizationPaths, GGameIni );
      if(!StaticData.GameLocalizationPaths.Num()) // Failed to find localization path.
      {
        UE_LOG(LogPaths, Warning, TEXT("No paths for game localization data were specifed in the game configuration."));
      }
      StaticData.bGameLocalizationPathsInitialized = true;
    }
  }
  return StaticData.GameLocalizationPaths;
}

会从GGameIni中读取（BaseGame.ini中已配置）：

BaseGame.ini
1
2
[Internationalization]
+LocalizationPaths=%GAMEDIR%Content/Localization/Game

Install IPA 0xE8008029 Error

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[DD] Mobile Device 'iPhone' connected
Trying to connect to mobile device running iOS ...
Transferring IPA to device 'iPhone' ...
 ... Transfer is 10% complete at phase 'TransferringPackage'
 ... Transfer is 20% complete at phase 'CopyingFile'
 ... Transfer is 30% complete at phase 'CopyingFile'
 ... Transfer is 40% complete at phase 'CopyingFile'
 ... Transfer is 50% complete at phase 'CopyingFile'
 ... Transfer is 60% complete at phase 'CopyingFile'
 ... Transfer is 80% complete at phase 'CopyingFile'
Installing IPA on device 'iPhone' ...
 ... Install is 5% complete at phase 'CreatingStagingDirectory'
 ... Install is 20% complete at phase 'InspectingPackage'
 ... Install is 40% complete at phase 'VerifyingApplication'
Install \ Update of "Blank425.ipa" failed with Unknown error 0xE8008029 in 13.65 seconds

在UE4.25中，cVersion2的值：

1
2
3
4
5
public class CodeDirectoryBlob : AbstractBlob
{
  public const UInt32 cVersion2 = 0x20200;
  // ...
}

获取引用的对象

可以获取UObject引用的对象信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
static int32 URamaStaticFunctionLib::GetObjReferenceCount(UObject* Obj, TArray<UObject*>* OutReferredToObjects = nullptr)
{
  if(!Obj || !Obj->IsValidLowLevelFast()) 
  {
    return -1;
  }
  
  TArray<UObject*> ReferredToObjects;       //req outer, ignore archetype, recursive, ignore transient
  FReferenceFinder ObjectReferenceCollector( ReferredToObjects, Obj, false, true, true, false);
  ObjectReferenceCollector.FindReferences( Obj );

        if(OutReferredToObjects)
  {
    OutReferredToObjects->Append(ReferredToObjects);
  }
  return OutReferredToObjects.Num();
}

AutomationTool Project

可以在项目中创建一个Automotion的项目，类似UGCExample中的那样，在Build/Script下创建UAT项目：Build/Scripts

UPL修改gradle.properties

修改Gradle的堆大小：

1
2
3
<gradleProperties>
  org.gradle.jvmargs=-Xmx9216M
</gradleProperties>

引擎中默认的为：UEDeployAndroid.cs#L3092

1
2
3
4
5
6
7
8
9
10
GradleProperties.AppendLine("org.gradle.daemon=false");
GradleProperties.AppendLine("org.gradle.jvmargs=-XX:MaxHeapSize=4096m -Xmx9216m");
GradleProperties.AppendLine("android.injected.testOnly=false");
GradleProperties.AppendLine(string.Format("COMPILE_SDK_VERSION={0}", CompileSDKVersion));
GradleProperties.AppendLine(string.Format("BUILD_TOOLS_VERSION={0}", BuildToolsVersion));
GradleProperties.AppendLine(string.Format("PACKAGE_NAME={0}", PackageName));
GradleProperties.AppendLine(string.Format("MIN_SDK_VERSION={0}", MinSDKVersion.ToString()));
GradleProperties.AppendLine(string.Format("TARGET_SDK_VERSION={0}", TargetSDKVersion.ToString()));
GradleProperties.AppendLine(string.Format("STORE_VERSION={0}", StoreVersion.ToString()));
GradleProperties.AppendLine(string.Format("VERSION_DISPLAY_NAME={0}", VersionDisplayName));

Timer的回调中不能析构handle

在Timer的回调里不能释放掉handle对象的内存，因为在回调之后，FTimeManager::Tick中在执行Delegate之后还有用到：

C#检测命令行参数

在build.cs以及target.cs中可以获取命令行参数，对编译选项进行控制：

1
2
3
4
5
string[] CmdArgs = Environment.GetCommandLineArgs();
foreach (string CmdLineArg in CmdArgs)
{
    Console.WriteLine("CmdLineArg: " + CmdLineArg);
}

编译时输出：

1
2
3
4
5
6
7
8
9
0>E:\UnrealEngine\Launcher\UE_4.26\Engine\Build\BatchFiles\Build.bat GWorldEditor Win64 Development -Project="E:\UnrealProjects\GWorld\GWorld.uproject" -WaitMutex -FromMsBuild -test
0>CmdLineArg: ..\..\Engine\Binaries\DotNET\UnrealBuildTool.exe
0>CmdLineArg: GWorldEditor
0>CmdLineArg: Win64
0>CmdLineArg: Development
0>CmdLineArg: -Project=E:\UnrealProjects\GWorld\GWorld.uproject
0>CmdLineArg: -WaitMutex
0>CmdLineArg: -FromMsBuild
0>CmdLineArg: -test

基于传递的参数可以动态地修改编译行为，比如添加宏、依赖的模块等。

IniPlatformName

因为如果只有打包的资源平台不同，App读取的ini存在共用，如下面这些，其实都对应基础的ini Platform：

  • WindowsNoEditor -> Windows
  • WindowsClient -> Windows
  • WindowsServer -> Windows
  • Android_ASTC -> Android
  • Android_2TC2 -> Android

可以通过以下方式转换：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
FString Conv2IniPlatform(const FString& Platform)
{
  FString Result;
  ITargetPlatformManagerModule& TPM = GetTargetPlatformManagerRef();
  const TArray<ITargetPlatform*>& TargetPlatforms = TPM.GetTargetPlatforms();
  TArray<ITargetPlatform*> CookPlatforms; 
  for (ITargetPlatform *TargetPlatform : TargetPlatforms)
  {
    if (TargetPlatform->PlatformName().Equals(Platform))
    {
      Result = TargetPlatform->IniPlatformName();
    }
  }
  return Result;
}

IOS内存阈值

距离FootPrint有100M的范围是比较保险的。

Device: (crash amount/total amount/percentage of total)

  • iPad1: 127MB/256MB/49%
  • iPad2: 275MB/512MB/53%
  • iPad3: 645MB/1024MB/62%
  • iPad4: 585MB/1024MB/57% (iOS 8.1)
  • iPad Mini 1st Generation: 297MB/512MB/58%
  • iPad Mini retina: 696MB/1024MB/68% (iOS 7.1)
  • iPad Air: 697MB/1024MB/68%
  • iPad Air 2: 1383MB/2048MB/68% (iOS 10.2.1)
  • iPad Pro 9.7”: 1395MB/1971MB/71% (iOS 10.0.2 (14A456))
  • iPad Pro 10.5”: 3057/4000/76% (iOS 11 beta4)
  • iPad Pro 12.9” (2015): 3058/3999/76% (iOS 11.2.1)
  • iPad Pro 12.9” (2017): 3057/3974/77% (iOS 11 beta4)
  • iPad Pro 11.0” (2018): 2858/3769/76% (iOS 12.1)
  • iPad Pro 12.9” (2018, 1TB): 4598/5650/81% (iOS 12.1)
  • iPad 10.2: 1844/2998/62% (iOS 13.2.3)
  • iPod touch 4th gen: 130MB/256MB/51% (iOS 6.1.1)
  • iPod touch 5th gen: 286MB/512MB/56% (iOS 7.0)
  • iPhone4: 325MB/512MB/63%
  • iPhone4s: 286MB/512MB/56%
  • iPhone5: 645MB/1024MB/62%
  • iPhone5s: 646MB/1024MB/63%
  • iPhone6: 645MB/1024MB/62% (iOS 8.x)
  • iPhone6+: 645MB/1024MB/62% (iOS 8.x)
  • iPhone6s: 1396MB/2048MB/68% (iOS 9.2)
  • iPhone6s+: 1392MB/2048MB/68% (iOS 10.2.1)
  • iPhoneSE: 1395MB/2048MB/69% (iOS 9.3)
  • iPhone7: 1395/2048MB/68% (iOS 10.2)
  • iPhone7+: 2040MB/3072MB/66% (iOS 10.2.1)
  • iPhone8: 1364/1990MB/70% (iOS 12.1)
  • iPhone X: 1392/2785/50% (iOS 11.2.1)
  • iPhone XS: 2040/3754/54% (iOS 12.1)
  • iPhone XS Max: 2039/3735/55% (iOS 12.1)
  • iPhone XR: 1792/2813/63% (iOS 12.1)
  • iPhone 11: 2068/3844/54% (iOS 13.1.3)
  • iPhone 11 Pro Max: 2067/3740/55% (iOS 13.2.3)

ensure

在shipping时不会Break。

Runtime\Core\Public\Misc\AssertionMacros.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
/**
 * ensure() can be used to test for *non-fatal* errors at runtime
 *
 * Rather than crashing, an error report (with a full call stack) will be logged and submitted to the crash server. 
 * This is useful when you want runtime code verification but you're handling the error case anyway.
 *
 * Note: ensure() can be nested within conditionals!
 *
 * Example:
 *
 *    if (ensure(InObject != nullptr))
 *    {
 *      InObject->Modify();
 *    }
 *
 * This code is safe to execute as the pointer dereference is wrapped in a non-nullptr conditional block, but
 * you still want to find out if this ever happens so you can avoid side effects.  Using ensure() here will
 * force a crash report to be generated without crashing the application (and potentially causing editor
 * users to lose unsaved work.)
 *
 * ensure() resolves to just evaluate the expression when DO_CHECK is 0 (typically shipping or test builds).
 *
 * By default a given call site will only print the callstack and submit the 'crash report' the first time an
 * ensure is hit in a session; ensureAlways can be used instead if you want to handle every failure
 */

#if DO_CHECK && !USING_CODE_ANALYSIS // The Visual Studio 2013 analyzer doesn't understand these complex conditionals

  #define UE_ENSURE_IMPL(Capture, Always, InExpression, ...) \
    (LIKELY(!!(InExpression)) || (DispatchCheckVerify<bool>([Capture] () FORCENOINLINE UE_DEBUG_SECTION \
    { \
      static bool bExecuted = false; \
      if ((!bExecuted || Always) && FPlatformMisc::IsEnsureAllowed()) \
      { \
        bExecuted = true; \
        FDebug::OptionallyLogFormattedEnsureMessageReturningFalse(true, #InExpression, __FILE__, __LINE__, ##__VA_ARGS__); \
        if (!FPlatformMisc::IsDebuggerPresent()) \
        { \
          FPlatformMisc::PromptForRemoteDebugging(true); \
          return false; \
        } \
        return true; \
      } \
      return false; \
    }) && ([] () { PLATFORM_BREAK(); } (), false)))

  #define ensure(           InExpression                ) UE_ENSURE_IMPL( , false, InExpression, TEXT(""))
  #define ensureMsgf(       InExpression, InFormat, ... ) UE_ENSURE_IMPL(&, false, InExpression, InFormat, ##__VA_ARGS__)
  #define ensureAlways(     InExpression                ) UE_ENSURE_IMPL( , true,  InExpression, TEXT(""))
  #define ensureAlwaysMsgf( InExpression, InFormat, ... ) UE_ENSURE_IMPL(&, true,  InExpression, InFormat, ##__VA_ARGS__)

#else // DO_CHECK

  #define ensure(           InExpression                ) (!!(InExpression))
  #define ensureMsgf(       InExpression, InFormat, ... ) (!!(InExpression))
  #define ensureAlways(     InExpression                ) (!!(InExpression))
  #define ensureAlwaysMsgf( InExpression, InFormat, ... ) (!!(InExpression))

#endif  // DO_CHECK

堡垒之夜为多平台的内容优化

自动化测试框架

《堡垒之夜》跨平台开发迭代经验分享

Cooker优化

  1. Shared DDC 必须要使用，对于常规的资源，DDC是一种非常有效的加速手段，例如纹理压缩需要在多个平台分别处理，而且压缩算法非常稳定，通过使用DDC，仅需要处理一次即可。
  2. Shaders与Texture 不同， 经常会发生变化，编译 Shader 可以使用 XGE （IncrediBuild）加速。（注：Fastbuild 好像也可以并行编译Shader，网上有相关的教程）

当DDC已经完全使用以后，Cook就成为了一个完全主线程绑定的任务了，它需要反复加载、保存资源，无法利用多线程进行并行化。所以建议最好使用核数较少，但是单核主频较高的主机进行Cook处理。

  1. 在 DefaultEngine.ini 设置 MaxMemoryAllowance 增大 Cook 使用内存数量，默认是16G。（注：Cook 是 IO密集，所以增加内存使用量可以减少因为内存不足导致的 Purge 次数）
  2. 使用 FCookModificationDelegate 来控制需要 Cook 的 Asset 数量。

Device Profile

在线迭代

RootComponent警告

1
LogActor: Warning: Bullet /Game/Map.Map:PersistentLevel.Bullet_0 has natively added scene component(s), but none of them were set as the actor's RootComponent - picking one arbitrarily

这是因为直接在无参构造函数里写了赋值：

1
2
3
4
5
ABullet::ABullet()
{
  PrimaryActorTick.bCanEverTick = true;
  RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("RootComponent"));
}

加上SetRootComponent或者在FObjectInitializer构造函数里写（建议）即可：

1
2
USceneComponent* NewRootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("RootComponent"));
SetRootComponent(NewRootComponent);

就像：

Runtime/Engine/Private/Camera/CameraActor.cpp
1
2
3
4
5
6
7
8
9
ACameraActor::ACameraActor(const FObjectInitializer& ObjectInitializer)
  : Super(ObjectInitializer)
{
  SceneComponent = CreateDefaultSubobject<USceneComponent>(TEXT("SceneComponent"));

  // Make the scene component the root component
  RootComponent = SceneComponent;
  // ...  
}

ConfigLayer

引擎Config的文件路径规则：

Runtime\Core\Private\Misc\ConfigCacheIni.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/**
 * Structure to define all the layers of the config system. Layers can be expanded by expansion files (NoRedist, etc), or by ini platform parents
 * (coming soon from another branch)
 */
struct FConfigLayer
{
  // Used by the editor to display in the ini-editor
  const TCHAR* EditorName;
  // Path to the ini file (with variables)
  const TCHAR* Path;
  // Path to the platform extension version
  const TCHAR* PlatformExtensionPath;
  // Special flag
  EConfigLayerFlags Flag;

} GConfigLayers[] =
{
  /**************************************************
  **** CRITICAL NOTES
  **** If you change this array, you need to also change EnumerateConfigFileLocations() in ConfigHierarchy.cs!!!
  **** And maybe UObject::GetDefaultConfigFilename(), UObject::GetGlobalUserConfigFilename()
  **************************************************/

  // Engine/Base.ini
  { TEXT("AbsoluteBase"),       TEXT("{ENGINE}Base.ini"), TEXT(""), EConfigLayerFlags::Required },
  
  // Engine/Base*.ini
  { TEXT("Base"),           TEXT("{ENGINE}{ED}{EF}Base{TYPE}.ini") },
  // Engine/Platform/BasePlatform*.ini
  { TEXT("BasePlatform"),       TEXT("{ENGINE}{ED}{PLATFORM}/{EF}Base{PLATFORM}{TYPE}.ini"), TEXT("{EXTENGINE}/{ED}{EF}Base{PLATFORM}{TYPE}.ini"),  },
  // Project/Default*.ini
  { TEXT("ProjectDefault"),     TEXT("{PROJECT}{ED}{EF}Default{TYPE}.ini"), TEXT(""), EConfigLayerFlags::AllowCommandLineOverride | EConfigLayerFlags::GenerateCacheKey },
  // Engine/Platform/Platform*.ini
  { TEXT("EnginePlatform"),     TEXT("{ENGINE}{ED}{PLATFORM}/{EF}{PLATFORM}{TYPE}.ini"), TEXT("{EXTENGINE}/{ED}{EF}{PLATFORM}{TYPE}.ini") },
  // Project/Platform/Platform*.ini
  { TEXT("ProjectPlatform"),      TEXT("{PROJECT}{ED}{PLATFORM}/{EF}{PLATFORM}{TYPE}.ini"), TEXT("{EXTPROJECT}/{ED}{EF}{PLATFORM}{TYPE}.ini") },
  
  // UserSettings/.../User*.ini
  { TEXT("UserSettingsDir"),      TEXT("{USERSETTINGS}Unreal Engine/Engine/Config/User{TYPE}.ini") },
  // UserDir/.../User*.ini
  { TEXT("UserDir"),          TEXT("{USER}Unreal Engine/Engine/Config/User{TYPE}.ini") },
  // Project/User*.ini
  { TEXT("GameDirUser"),        TEXT("{PROJECT}User{TYPE}.ini"), TEXT(""), EConfigLayerFlags::GenerateCacheKey },
};

Mac生成的xocde工程

在UE项目的Intermediate/ProjectFilesIOS目录下，会创建一个项目同名的xcodeproj并且具有UE4.xcodeproj文件。

Unreal Insight默认端口

在Unreal Insight启动时默认监听本地的1980端口：

Source/Developer/TraceInsights/Private/Insights/TraceInsightsModule.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void FTraceInsightsModule::CreateDefaultStore()
{
  const FString StoreDir = FPaths::ProjectSavedDir() / TEXT("TraceSessions");

  FInsightsManager::Get()->SetStoreDir(StoreDir);

  // Create the Store Service.
  Trace::FStoreService::FDesc StoreServiceDesc;
  StoreServiceDesc.StoreDir = *StoreDir;
  StoreServiceDesc.RecorderPort = 1980;
  StoreServiceDesc.ThreadCount = 2;
  StoreService = TUniquePtr<Trace::FStoreService>(Trace::FStoreService::Create(StoreServiceDesc));

  if (StoreService.IsValid())
  {
    ConnectToStore(TEXT("127.0.0.1"), StoreService->GetPort());
  }
}

Unreal Insight的启动：Programs/UnrealInsights/Private/UserInterfaceCommand.cpp#L211。

可以传递给Unreal Insight的参数:

  • -OpenTraceId=
  • -Store=：-Store=127.0.0.1:1980
  • -StoreHost=
  • -StorePort=
  • -ExecOnAnalysisCompleteCmd=
  • -AutoQuit
  • -InsightsTest
  • -DebugTools

当地图相当大，在生成导航时会有以下提示：

1
LogNavigation: Error: Navmesh bounds are too large! Limiting requested tiles count (5472000) to: (1048576) for RecastNavMesh /Game/Level/Map.Map:PersistentLevel.RecastNavMesh-Default

这是因为地图太大，超出了Tile的数量限制。
引擎中默认Tile的最大数量为1<<20也就是1048576，这个值可以修改配置，但不能大于1<<30(因为它用int32存储)。

Source/Runtime/NavigationSystem/Public/NavMesh/RecastNavMesh.h
1
2
3
4
5
6
7
8
9
10
11
12
UCLASS(config=Engine, defaultconfig, hidecategories=(Input,Rendering,Tags,"Utilities|Transformation",Actor,Layers,Replication), notplaceable)
class NAVIGATIONSYSTEM_API ARecastNavMesh : public ANavigationData
{
  // ...
  /** Absolute hard limit to number of navmesh tiles. Be very, very careful while modifying it while
   *  having big maps with navmesh. A single, empty tile takes 176 bytes and empty tiles are
   *  allocated up front (subject to change, but that's where it's at now)
   *  @note TileNumberHardLimit is always rounded up to the closest power of 2 */
  UPROPERTY(EditAnywhere, Category = Generation, config, meta = (ClampMin = "1", UIMin = "1"), AdvancedDisplay)
  int32 TileNumberHardLimit;
    // ...
};

以及使用：

Runtime/NavigationSystem/Private/NavMesh/RecastNavMesh.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
FRecastNavMeshGenerationProperties::FRecastNavMeshGenerationProperties()
{
  TilePoolSize = 1024;
  TileSizeUU = 988.f;
  CellSize = 19;
  CellHeight = 10;
  AgentRadius = 34.f;
  AgentHeight = 144.f;
  AgentMaxSlope = 44.f;
  AgentMaxStepHeight = 35.f;
  MinRegionArea = 0.f;
  MergeRegionSize = 400.f;
  MaxSimplificationError = 1.3f;  // from RecastDemo
  TileNumberHardLimit = 1 << 20;
  RegionPartitioning = ERecastPartitioning::Watershed;
  LayerPartitioning = ERecastPartitioning::Watershed;
  RegionChunkSplits = 2;
  LayerChunkSplits = 2;
  bSortNavigationAreasByCost = false;
  bPerformVoxelFiltering = true;
  bMarkLowHeightAreas = false;
  bUseExtraTopCellWhenMarkingAreas = true;
  bFilterLowSpanSequences = false;
  bFilterLowSpanFromTileCache = false;
  bFixedTilePoolSize = false;
}

FRecastNavMeshGenerationProperties::FRecastNavMeshGenerationProperties(const ARecastNavMesh& RecastNavMesh)
{
  TilePoolSize = RecastNavMesh.TilePoolSize;
  TileSizeUU = RecastNavMesh.TileSizeUU;
  CellSize = RecastNavMesh.CellSize;
  CellHeight = RecastNavMesh.CellHeight;
  AgentRadius = RecastNavMesh.AgentRadius;
  AgentHeight = RecastNavMesh.AgentHeight;
  AgentMaxSlope = RecastNavMesh.AgentMaxSlope;
  AgentMaxStepHeight = RecastNavMesh.AgentMaxStepHeight;
  MinRegionArea = RecastNavMesh.MinRegionArea;
  MergeRegionSize = RecastNavMesh.MergeRegionSize;
  MaxSimplificationError = RecastNavMesh.MaxSimplificationError;
  TileNumberHardLimit = RecastNavMesh.TileNumberHardLimit;
  RegionPartitioning = RecastNavMesh.RegionPartitioning;
  LayerPartitioning = RecastNavMesh.LayerPartitioning;
  RegionChunkSplits = RecastNavMesh.RegionChunkSplits;
  LayerChunkSplits = RecastNavMesh.LayerChunkSplits;
  bSortNavigationAreasByCost = RecastNavMesh.bSortNavigationAreasByCost;
  bPerformVoxelFiltering = RecastNavMesh.bPerformVoxelFiltering;
  bMarkLowHeightAreas = RecastNavMesh.bMarkLowHeightAreas;
  bUseExtraTopCellWhenMarkingAreas = RecastNavMesh.bUseExtraTopCellWhenMarkingAreas;
  bFilterLowSpanSequences = RecastNavMesh.bFilterLowSpanSequences;
  bFilterLowSpanFromTileCache = RecastNavMesh.bFilterLowSpanFromTileCache;
  bFixedTilePoolSize = RecastNavMesh.bFixedTilePoolSize;
}
ARecastNavMesh::ARecastNavMesh(const FObjectInitializer& ObjectInitializer)
  : Super(ObjectInitializer)
  , bDrawFilledPolys(true)
  , bDrawNavMeshEdges(true)
  , bDrawNavLinks(true)
  , bDrawOctreeDetails(true)
  , bDrawMarkedForbiddenPolys(false)
  , bDistinctlyDrawTilesBeingBuilt(true)
  , DrawOffset(10.f)
  , TilePoolSize(1024)
  , MaxSimplificationError(1.3f)  // from RecastDemo
  , DefaultMaxSearchNodes(RECAST_MAX_SEARCH_NODES)
  , DefaultMaxHierarchicalSearchNodes(RECAST_MAX_SEARCH_NODES)
  , bPerformVoxelFiltering(true)  
  , bMarkLowHeightAreas(false)
  , bUseExtraTopCellWhenMarkingAreas(true)
  , bFilterLowSpanSequences(false)
  , bFilterLowSpanFromTileCache(false)
  , bStoreEmptyTileLayers(false)
  , bUseVirtualFilters(true)
  , bAllowNavLinkAsPathEnd(false)
  , TileSetUpdateInterval(1.0f)
  , NavMeshVersion(NAVMESHVER_LATEST) 
  , RecastNavMeshImpl(NULL)
{
  HeuristicScale = 0.999f;
  RegionPartitioning = ERecastPartitioning::Watershed;
  LayerPartitioning = ERecastPartitioning::Watershed;
  RegionChunkSplits = 2;
  LayerChunkSplits = 2;
  MaxSimultaneousTileGenerationJobsCount = 1024;
  bDoFullyAsyncNavDataGathering = false;
  TileNumberHardLimit = 1 << 20;

#if RECAST_ASYNC_REBUILDING
  BatchQueryCounter = 0;
#endif // RECAST_ASYNC_REBUILDING


  if (HasAnyFlags(RF_ClassDefaultObject) == false)
  {
    INC_DWORD_STAT_BY( STAT_NavigationMemory, sizeof(*this) );

    FindPathImplementation = FindPath;
    FindHierarchicalPathImplementation = FindPath;

    TestPathImplementation = TestPath;
    TestHierarchicalPathImplementation = TestHierarchicalPath;

    RaycastImplementation = NavMeshRaycast;

    RecastNavMeshImpl = new FPImplRecastNavMesh(this);
  
    // add predefined areas up front
    SupportedAreas.Add(FSupportedAreaData(UNavArea_Null::StaticClass(), RECAST_NULL_AREA));
    SupportedAreas.Add(FSupportedAreaData(UNavArea_LowHeight::StaticClass(), RECAST_LOW_AREA));
    SupportedAreas.Add(FSupportedAreaData(UNavArea_Default::StaticClass(), RECAST_DEFAULT_AREA));
  }
}

TileNumberHardLimit的值可以通过配置文件进行设置：

DefaultEngine.ini
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
[/Script/NavigationSystem.RecastNavMesh]
bDrawPolyEdges=False
bDistinctlyDrawTilesBeingBuilt=True
DrawOffset=10.000000
bFixedTilePoolSize=False
TilePoolSize=1024
TileSizeUU=1000.000000
CellSize=19.000000
CellHeight=10.000000
AgentRadius=34.000000
AgentHeight=144.000000
AgentMaxHeight=160.000000
AgentMaxSlope=44.000000
AgentMaxStepHeight=35.000000
MinRegionArea=0.000000
MergeRegionSize=400.000000
MaxSimplificationError=1.300000
MaxSimultaneousTileGenerationJobsCount=1024
TileNumberHardLimit=1048576
DefaultDrawDistance=5000.000000
DefaultMaxSearchNodes=2048.000000
DefaultMaxHierarchicalSearchNodes=2048.000000
RegionPartitioning=Watershed
LayerPartitioning=Watershed
RegionChunkSplits=2
LayerChunkSplits=2
bSortNavigationAreasByCost=False
bPerformVoxelFiltering=True
bMarkLowHeightAreas=False
bDoFullyAsyncNavDataGathering=False
bUseBetterOffsetsFromCorners=True
bUseVirtualFilters=True
bUseVoxelCache=False
TileSetUpdateInterval=1.000000
HeuristicScale=0.999000
VerticalDeviationFromGroundCompensation=0.000000
bForceRebuildOnLoad=True

加密PakIndex造成的无法挂载shaderbytecode

在UE5中Project Settings-Crypto中开启EncryptPakIndex，发现在自动挂载中无法加载最新的Shaderbytecode，造成材质丢失（不确定UE4中是否存在）。

运行时给Enum添加值

通过UEnum的SetEnums可以实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
UEnum* TargetPlatform = UFlibPatchParserHelper::GetUEnum<ETargetPlatform>();
uint64 MaxEnumValue = TargetPlatform->GetMaxEnumValue();
FString EnumName = TargetPlatform->GetName();
TArray<TPair<FName, int64>> EnumNames;

for (ETargetPlatform Platform:TEnumRange<ETargetPlatform>())
{
  EnumNames.Emplace(TargetPlatform->GetNameByValue((int64)Platform),(int64)Platform);
}
for(const auto& AppendEnumItem:AppendPlatformEnums)
{
  ++MaxEnumValue;
  EnumNames.Emplace(
    FName(*FString::Printf(TEXT("%s::%s"),*EnumName,*AppendEnumItem)),
    MaxEnumValue
  );
}
#if ENGINE_MAJOR_VERSION > 4 || ENGINE_MINOR_VERSION > 25
TargetPlatform->SetEnums(EnumNames,UEnum::ECppForm::EnumClass,EEnumFlags::None,true);
#else
TargetPlatform->SetEnums(EnumNames,UEnum::ECppForm::EnumClass,true);
#endif

遍历Enum的所有值

需要用ENUM_RANGE_BY_COUNT标记，然后可以用TEnumRange遍历。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
UENUM()
enum class ETargetPlatform : uint8
{
  None,
  AllPlatforms,
  Count UMETA(Hidden)
};
ENUM_RANGE_BY_COUNT(ETargetPlatform, ETargetPlatform::Count);

// for each
for (ETargetPlatform Platform:TEnumRange<ETargetPlatform>())
{
  //...
}

IoStore的生成分析

UE4.25添加了一个新的打包选项IO Store（在UE5中默认开启）：

Youtube上Epic JP有一个介绍视频：【UE4.25 新機能】ロードの高速化機能「IOStore」について

在UE5中默认是开启的，打包时除了pak之外多了两种类型的文件：ucas与utoc，在运行时Mount pak时也会mount它们，看了下代码在UE4.25/26就中存在，有时间详细地分析下它们的作用和加载流程。

它们也在CopyBuildToStagingDirectory.Automation.cs文件中的CreatePaks函数中和Pak一同创建：

Programs\AutomationTool\Scripts\CopyBuildToStagingDirectory.Automation.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
private static bool ShouldCreateIoStoreContainerFiles(ProjectParams Params, Platform StageTargetPlatform)
{
  if (Params.CookOnTheFly)
  {
    return false;
  }

  if (Params.SkipIoStore)
  {
    return false;
  }

  if (Params.IoStore)
  {
    return true;
  }

  if (Params.Stage && !Params.SkipStage)
  {
    ConfigHierarchy PlatformGameConfig = ConfigCache.ReadHierarchy(ConfigHierarchyType.Game, DirectoryReference.FromFile(Params.RawProjectPath), StageTargetPlatform.IniPlatformType);
    bool bUseIoStore = false;
    PlatformGameConfig.GetBool("/Script/UnrealEd.ProjectPackagingSettings", "bUseIoStore", out bUseIoStore);
    return bUseIoStore;
  }

  return false;
}

private static void CreatePaks(ProjectParams Params, DeploymentContext SC, List<CreatePakParams> PakParamsList, EncryptionAndSigning.CryptoSettings CryptoSettings, FileReference CryptoKeysCacheFilename)
{
  // ...
  if (ShouldCreateIoStoreContainerFiles(Params, SC.StageTargetPlatform))
  {
    bool bAllowBulkDataInIoStore = true;
    if(!PlatformEngineConfig.GetBool("Core.System", "AllowBulkDataInIoStore", out bAllowBulkDataInIoStore))
    {
      bAllowBulkDataInIoStore = true; // Default is to allow it in the IoStore
    }

    UnrealPakResponseFile = new Dictionary<string, string>();
    Dictionary<string, string> IoStoreResponseFile = new Dictionary<string, string>();
    foreach (var Entry in PakParams.UnrealPakResponseFile)
    {
      // Temporary solution to filter non cooked packages from I/O store container file(s)
      if (SC.OnlyAllowPackagesFromStdCookPathInIoStore && !Entry.Key.ToLower().Contains("\\saved\\cooked\\"))
      {
        UnrealPakResponseFile.Add(Entry.Key, Entry.Value);
        continue;
      }

      if (Path.GetExtension(Entry.Key).Contains(".uasset") ||
        Path.GetExtension(Entry.Key).Contains(".umap"))
      {
        IoStoreResponseFile.Add(Entry.Key, Entry.Value);
      }
      else if(Path.GetExtension(Entry.Key).Contains(".ubulk") ||
          Path.GetExtension(Entry.Key).Contains(".uptnl"))
      {
        if(bAllowBulkDataInIoStore)
        {
          IoStoreResponseFile.Add(Entry.Key, Entry.Value);
        }
        else
        {
          UnrealPakResponseFile.Add(Entry.Key, Entry.Value);
        }
      }
      else if (!Path.GetExtension(Entry.Key).Contains(".uexp"))
      {
        UnrealPakResponseFile.Add(Entry.Key, Entry.Value);
      }

    }

    string ContainerPatchSourcePath = null;
    if (Params.HasBasedOnReleaseVersion)
    {
      string ContainerWildcard = PakParams.PakName + "-" + SC.FinalCookPlatform + "*.utoc";
      ContainerPatchSourcePath = CombinePaths(Params.GetBasedOnReleaseVersionPath(SC, Params.Client), ContainerWildcard);
    }
    bool bGenerateDiffPatch = bShouldGeneratePatch && !ShouldSkipGeneratingPatch(PlatformGameConfig, PakParams.PakName);
    bool bCompressContainers = PakParams.bCompressed || Params.AdditionalIoStoreOptions.Contains("-compressed");

    IoStoreCommands.Add(GetIoStoreCommandArguments(
      IoStoreResponseFile,
      PakParams.PakName,
      OutputLocation,
      bCompressContainers,
      CryptoSettings,
      PakParams.EncryptionKeyGuid,
      ContainerPatchSourcePath,
      bGenerateDiffPatch,
      Params.HasDLCName));
  }
  // ...
}

与生成Pak类似，也会生成一个PakListIoStore_*.txt的文件，格式与Paklist*.txt相同。

1
2
3
4
5
6
7
"C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\Saved\Cooked\Windows\ThirdPerson_UE5\Content\BP_GF_Actor.uasset" "../../../ThirdPerson_UE5/Content/BP_GF_Actor.uasset"
"C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\Saved\Cooked\Windows\Engine\Content\Animation\DefaultAnimBoneCompressionSettings.uasset" "../../../Engine/Content/Animation/DefaultAnimBoneCompressionSettings.uasset"
"C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\Saved\Cooked\Windows\Engine\Content\Animation\DefaultAnimCurveCompressionSettings.uasset" "../../../Engine/Content/Animation/DefaultAnimCurveCompressionSettings.uasset"
"C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\Saved\Cooked\Windows\Engine\Content\BasicShapes\Cone.uasset" "../../../Engine/Content/BasicShapes/Cone.uasset"
"C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\Saved\Cooked\Windows\Engine\Content\BasicShapes\Cone.ubulk" "../../../Engine/Content/BasicShapes/Cone.ubulk"
"C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\Saved\Cooked\Windows\Engine\Content\BasicShapes\Cube.uasset" "../../../Engine/Content/BasicShapes/Cube.uasset"
"C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\Saved\Cooked\Windows\Engine\Content\BasicShapes\Cube.ubulk" "../../../Engine/Content/BasicShapes/Cube.ubulk"

但里面只包含.uasset/.umap的资源，其余的文件存储在pak中，相当于把原本的pak文件拆分成utoc和pak两个文件，加速IO。

UE提供了一个Commandlet，方便调用：

Editor/UnrealEd/Private/Commandlets/IoStoreCommandlet.cpp
1
2
3
4
int32 UIoStoreCommandlet::Main(const FString& Params)
{
  return CreateIoStoreContainerFiles(*Params);
}

核心实现是在IoStoreUtilities.cpp中定义的CreateIoStoreContainerFiles函数。

IoStoreCommandlet的调用方式：

1
2
3
4
5
6
7
8
9
10
"C:\Program Files\Epic Games\UE_5.0ea\Engine\Binaries\Win64\UnrealEditor-Cmd.exe"
"C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\ThirdPerson_UE5.uproject"
-run=IoStore
-CreateGlobalContainer="C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\Saved\StagedBuilds\Windows\ThirdPerson_UE5\Content\Paks\global.utoc"
-CookedDirectory="C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\Saved\Cooked\Windows"
-Commands="C:\Users\lipengzha\AppData\Roaming\Unreal Engine\AutomationTool\Logs\C+Program+Files+Epic+Games+UE_5.0ea\IoStoreCommands.txt"
-CookerOrder="C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\Build\Windows\FileOpenOrder\CookerOpenOrder.log"
-patchpaddingalign=2048
-cryptokeys="C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\Saved\Cooked\Windows\ThirdPerson_UE5\Metadata\Crypto.json"
-TargetPlatform=Windows

最小执行命令：

1
2
3
4
5
6
7
8
Engine\Binaries\Win64\UE4Editor-Cmd.exe
E:\UnrealProjects\StarterContent\StarterContent.uproject
-run=IoStore
-CreateGlobalContainer=E:\UnrealProjects\StarterContent\Saved\StagedBuilds\WindowsNoEditor\StarterContent\Content\Paks\global.utoc
-CookedDirectory=E:\UnrealProjects\StarterContent\Saved\Cooked\WindowsNoEditor
-Commands="C:\Users\visionsmile\AppData\Roaming\Unreal Engine\AutomationTool\Logs\E+UnrealEngine+Launcher+UE_4.26\IoStoreCommands.txt"
-CookerOrder="C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\Build\Windows\FileOpenOrder\CookerOpenOrder.log"
-TargetPlatform=WindowsNoEditor

IoStoreCommands.txt的内容为：

1
-Output="D:\ThirdPerson_UE5\Saved\StagedBuilds\Windows\ThirdPerson_UE5\Content\Paks\ThirdPerson_UE5-Windows.utoc" -ContainerName=ThirdPerson_UE5 -ResponseFile="D:\PakListIoStore_ThirdPerson_UE5.txt"

创建IO Store的Log：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
LogIoStore: Display: ==================== IoStore Utils ====================
LogIoStore: Display: Parsing crypto keys from a crypto key cache file 'C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\Saved\Cooked\Windows\ThirdPerson_UE5\Metadata\Crypto.json'
LogIoStore: Display: Container signing - DISABLED
LogIoStore: Display: Directory index - ENABLED
LogIoStore: Display: Using memory mapping alignment '16384'
LogIoStore: Display: Using compression block size '65536'
LogIoStore: Display: Using compression block alignment '2048'
LogIoStore: Display: Using max partition size '0'
LogIoStore: Display: Using command list file: 'C:\Users\lipengzha\AppData\Roaming\Unreal Engine\AutomationTool\Logs\C+Program+Files+Epic+Games+UE_5.0ea\IoStoreCommands.txt'
LogIoStore: Display: Using target platform 'Windows'
LogIoStore: Display: Searching for cooked assets in folder 'C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\Saved\Cooked\Windows'
LogIoStore: Display: Found '1342' files
LogIoStore: Display: Loaded Bulk Data manifest 'C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson_UE5\Saved\Cooked\Windows/ThirdPerson_UE5/Metadata/BulkDataInfo.ubulkmanifest'
LogIoStore: Display: Creating container targets...
LogIoStore: Display: Parsing packages...
LogIoStore: Display: Reading package assets...
LogIoStore: Display: Parsing package assets...
LogIoStore: Display: Parsing 0/556: 'C:/Users/lipengzha/Documents/Unreal Projects/ThirdPerson_UE5/Saved/Cooked/Windows/ThirdPerson_UE5/Content/ThirdPersonCPP/Chunks/BP_LightInstance.uasset'
LogIoStore: Display: Creating global script objects...
LogIoStore: Display: Creating global imports and exports...
LogIoStore: Display: Converting export map import indices...
LogIoStore: Display: Conforming localized packages...
LogIoStore: Display: Adding localized import packages...
LogIoStore: Display: Conforming localized imports...
LogIoStore: Display: Adding preload dependencies...
LogIoStore: Display: Building bundles...
LogIoStore: Display: Finalizing name maps...
LogIoStore: Display: Finalizing package headers...
LogIoStore: Display: Creating disk layout...
LogIoStore: Display: Ordered 0/556 packages using game open order
LogIoStore: Display: Ordered 551/556 packages using cooker open order
LogIoStore: Display: Ordered 5 packages using fallback bundle order
LogIoStore: Display: Finalizing initial load...
LogIoStore: Display: Serializing global meta data
LogIoStore: Display: Saving global name map to container file
LogIoStore: Display: Serializing container(s)...
LogIoStore: Display: Hashed, Compressed, Serialized: 790, 790, 790 / 790
LogIoStore: Display: Calculating stats...
LogIoStore: Display: --------------------------------------------------- IoDispatcher --------------------------------------------------------
LogIoStore: Display:
LogIoStore: Display: Container                           Flags   TOC Size (KB)     TOC Entries       Size (MB)           Compressed (MB)
LogIoStore: Display: -------------------------------------------------------------------------------------------------------------------------
LogIoStore: Display: global                            -/-/-/-            0.52               3            1.10                         -
LogIoStore: Display: ThirdPerson_UE5-Windows           -/-/-/I          189.89             787          571.22                         -
LogIoStore: Display: TOTAL                                              190.41             790          572.32                         -
LogIoStore: Display:
LogIoStore: Display: ** Flags: (C)ompressed / (E)ncrypted / (S)igned) / (I)ndexed) **
LogIoStore: Display:
LogIoStore: Display: Compression block padding:     0.55 MB
LogIoStore: Display:
LogIoStore: Display: -------------------------------------------- Container Directory Index --------------------------------------------------
LogIoStore: Display: Container                            Size (KB)
LogIoStore: Display: global                                    0.00
LogIoStore: Display: ThirdPerson_UE5-Windows                  33.53
LogIoStore: Display:
LogIoStore: Display: ---------------------------------------------- Container Patch Report ---------------------------------------------------
LogIoStore: Display: Container                         Total (count) Modified (count)    Added (count)    Modified (MB)       Added (MB)
LogIoStore: Display: global                                        3                0                0             0.00             0.00
LogIoStore: Display: ThirdPerson_UE5-Windows                     787                0              787             0.00           570.67
LogIoStore: Display:
LogIoStore: Display:
LogIoStore: Display: --------------------------------------------------- PackageStore (KB) ---------------------------------------------------
LogIoStore: Display:
LogIoStore: Display: Container                                Store Size             Packages            Localized
LogIoStore: Display: -------------------------------------------------------------------------------------------------------------------------
LogIoStore: Display: ThirdPerson_UE5                                  22                  556                    0
LogIoStore: Display: TOTAL                                            22                  556                    0
LogIoStore: Display:
LogIoStore: Display:
LogIoStore: Display: --------------------------------------------------- PackageHeader (KB) --------------------------------------------------
LogIoStore: Display:
LogIoStore: Display: Container                             Header       Summary         Graph     ImportMap     ExportMap       NameMap
LogIoStore: Display: -------------------------------------------------------------------------------------------------------------------------
LogIoStore: Display: ThirdPerson_UE5                          911            35            15            35           165           662
LogIoStore: Display: TOTAL                                    911            35            15            35           165           662
LogIoStore: Display:
LogIoStore: Display:
LogIoStore: Display: Input:    132.91 MB UExp
LogIoStore: Display: Input:      1.12 MB UAsset
LogIoStore: Display: Input:      0.10 MB FPackageFileSummary
LogIoStore: Display: Input:       556 Packages
LogIoStore: Display: Input:       641 Imported package entries
LogIoStore: Display: Input:       327 Packages without imports
LogIoStore: Display: Input:     26088 Name map entries
LogIoStore: Display: Input:     10631 PreloadDependencies entries
LogIoStore: Display: Input:      4480 ImportMap entries
LogIoStore: Display: Input:      2342 ExportMap entries
LogIoStore: Display: Input:       712 Public exports
LogIoStore: Display:
LogIoStore: Display: Output:      558 Export bundles
LogIoStore: Display: Output:     4684 Export bundle entries
LogIoStore: Display: Output:      641 Export bundle arcs
LogIoStore: Display: Output:    18041 Public runtime script objects
LogIoStore: Display: Output:     1.10 MB InitialLoadData
LogInit: Display:
LogInit: Display: Warning/Error Summary (Unique only)
LogInit: Display: -----------------------------------

引擎中mount ucas/utoc的Initialize代码在：IPlatformFilePak.cpp#L7136

FIoDispatcher也在IPlatformFilePak.cpp的Initialize中初始化：IPlatformFilePak.cpp#L6862

运行时Log：

1
2
3
4
5
6
7
8
9
10
11
12
13
LogIoDispatcher: Display: Reading toc: ../../../ThirdPerson_UE5/Content/Paks/global.utoc
LogIoDispatcher: Display: Mounting container '../../../ThirdPerson_UE5/Content/Paks/global' in location slot 0
LogPakFile: Display: Initialized I/O dispatcher
LogPakFile: Display: Found Pak file ../../../ThirdPerson_UE5/Content/Paks/ThirdPerson_UE5-Windows.pak attempting to mount.
LogPakFile: Display: Mounting pak file ../../../ThirdPerson_UE5/Content/Paks/ThirdPerson_UE5-Windows.pak.
LogPakFile: PakFile PrimaryIndexSize=14754
LogPakFile: PakFile PathHashIndexSize=37787
LogPakFile: PakFile FullDirectoryIndexSize=36832
LogIoDispatcher: Display: Reading toc: ../../../ThirdPerson_UE5/Content/Paks/ThirdPerson_UE5-Windows.utoc
LogIoDispatcher: Display: Mounting container '../../../ThirdPerson_UE5/Content/Paks/ThirdPerson_UE5-Windows' in location slot 0
LogPakFile: Display: Mounted IoStore container "../../../ThirdPerson_UE5/Content/Paks/ThirdPerson_UE5-Windows"
LogShaderLibrary: Display: ShaderCodeLibraryPakFileMountedCallback: PakFile '../../../ThirdPerson_UE5/Content/Paks/ThirdPerson_UE5-Windows.pak' (chunk index -1, root '../../../') mounted
LogShaderLibrary: Display: ShaderCodeLibraryPakFileMountedCallback: pending pak file info (ChunkID:-1 Root:../../../ File:../../../ThirdPerson_UE5/Content/Paks/ThirdPerson_UE5-Windows.pak)

注意：UE5默认开启了Async Loading Thread Enabled，在加载时可能会遇到Shader失败的问题：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
[2021.06.04-07.56.38:156][144]LogNet: Browse: /Game/StarterContent/Maps/StarterMap
[2021.06.04-07.56.38:156][144]LogLoad: LoadMap: /Game/StarterContent/Maps/StarterMap
[2021.06.04-07.56.38:156][144]LogWorld: BeginTearingDown for /Game/NewMap
[2021.06.04-07.56.38:157][144]LogWorld: UWorld::CleanupWorld for NewMap, bSessionEnded=true, bCleanupResources=true
[2021.06.04-07.56.38:157][144]LogSlate: InvalidateAllWidgets triggered.  All widgets were invalidated
[2021.06.04-07.56.38:187][144]LogStreaming: Display: 0.035 ms (0.013+0.022) ms for processing 33/149 objects in NotifyUnreachableObjects( Queued=0, Async=0). Removed 12/12 (103->91 tracked) packages and 21/21 (139->118 tracked) public exports.
[2021.06.04-07.56.38:188][144]LogAudio: Display: Audio Device unregistered from world 'None'.
[2021.06.04-07.56.38:189][144]LogUObjectHash: Compacting FUObjectHashTables data took   0.54ms
[2021.06.04-07.56.38:192][144]LogStreaming: Display: FlushAsyncLoading: 1 QueuedPackages, 0 AsyncPackages
[2021.06.04-07.56.38:206][144]LogStreaming: Warning: ImportPackages: SkipPackage: None (0xC0782D3BC7B113E7) - Skipping non mounted imported package with id '0xA6A13DDB269EBB86'
[2021.06.04-07.56.38:206][144]LogStreaming: Warning: ImportPackages: SkipPackage: None (0x18C447EA162E9CF0) - Skipping non mounted imported package with id '0x592F17301901E4D4'
[2021.06.04-07.56.38:206][144]LogStreaming: Warning: ImportPackages: SkipPackage: None (0xAF2D3B82DFED12AB) - Skipping non mounted imported package with id '0x90DE907FA36D8947'
[2021.06.04-07.56.38:206][144]LogStreaming: Warning: ImportPackages: SkipPackage: None (0x89DE226562FF0557) - Skipping non mounted imported package with id '0x90DE907FA36D8947'
[2021.06.04-07.56.38:206][144]LogStreaming: Warning: ImportPackages: SkipPackage: None (0xFA20E9343783C7DC) - Skipping non mounted imported package with id '0x90DE907FA36D8947'
// .....
[2021.06.04-07.56.38:207][144]LogStreaming: Warning: ImportPackages: SkipPackage: None (0xB64F7A6CD99A047) - Skipping non mounted imported package with id '0x90DE907FA36D8947'
[2021.06.04-07.56.38:207][144]LogStreaming: Warning: ImportPackages: SkipPackage: None (0xFEFAEB73A2846157) - Skipping non mounted imported package with id '0x90DE907FA36D8947'
[2021.06.04-07.56.38:209][144]LogStreaming: Warning: ImportPackages: SkipPackage: None (0x997474132A59335D) - Skipping non mounted imported package with id '0x90DE907FA36D8947'
[2021.06.04-07.56.38:209][144]LogStreaming: Warning: LoadPackage: SkipPackage: /Game/StarterContent/Audio/Starter_Wind05 (0x5E446250F73B1FA8) - The package to load does not exist on disk or in the loader
[2021.06.04-07.56.38:209][144]LogStreaming: Warning: LoadPackage: SkipPackage: /Game/StarterContent/Audio/Starter_Birds01 (0x724FF2357C734AD2) - The package to load does not exist on disk or in the loader
[2021.06.04-07.56.38:209][144]LogStreaming: Warning: LoadPackage: SkipPackage: /Game/StarterContent/Audio/Starter_Wind06 (0x982833CC14F6C1E7) - The package to load does not exist on disk or in the loader
[2021.06.04-07.56.38:209][144]LogStreaming: Warning: LoadPackage: SkipPackage: /Game/StarterContent/Audio/Collapse01 (0x938C37337F3982BF) - The package to load does not exist on disk or in the loader
[2021.06.04-07.56.38:210][144]LogStreaming: Warning: LoadPackage: SkipPackage: /Game/StarterContent/Audio/Collapse02 (0x3820625B5DBE09A3) - The package to load does not exist on disk or in the loader
[2021.06.04-07.56.38:213][144]LogStreaming: Warning: LoadPackage: SkipPackage: /Game/StarterContent/Audio/Starter_Music01 (0x1D0AA270D31EFC87) - The package to load does not exist on disk or in the loader

在Project Settings-Engine-Streaming中关闭Async Loading Thread Enabled即可成功加载：

4.25.2- Mac打包的metal-ar错误

有执行metal-ar的报错：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
UATHelper: Packaging (iOS):   LogShaders: Error: Archiving failed: metal-ar failed with code 2: Couldn't posix_spawn: error 7
UATHelper: Packaging (iOS):   LogShaders: Error: Archiving failed: metal-ar failed with code 2: Couldn't posix_spawn: error 7
UATHelper: Packaging (iOS):   LogShaders: Error: Archiving failed: metal-ar failed with code 2: Couldn't posix_spawn: error 7
UATHelper: Packaging (iOS):   LogShaders: Error: Archiving failed: no valid input for metallib.
UATHelper: Packaging (iOS):   LogShaders: Error: Archiving failed: no valid input for metallib.
UATHelper: Packaging (iOS):   LogShaders: Error: Archiving failed: no valid input for metallib.
UATHelper: Packaging (iOS):   LogZipArchiveWriter: Display: Closing zip file with 25491 entries.
UATHelper: Packaging (iOS):   CookResults: Error: Package Native Shader Library failed for IOS.
UATHelper: Packaging (iOS):   LogCook: Display: Saved scl.csv /Users/buildmachine/Documents/BuildWorkspace/workspace/PackageClient/Client/Saved/Cooked/IOS/FGame/Metadata/PipelineCaches/ShaderStableInfo-Global-SF_METAL.scl.csv for platform IOS
UATHelper: Packaging (iOS):   LogCook: Display: Saved scl.csv /Users/buildmachine/Documents/BuildWorkspace/workspace/PackageClient/Client/Saved/Cooked/IOS/FGame/Metadata/PipelineCaches/ShaderStableInfo-FGame-SF_METAL.scl.csv for platform IOS
PackagingResults: Error: Archiving failed: metal-ar failed with code 2: Couldn't posix_spawn: error 7
PackagingResults: Error: Archiving failed: metal-ar failed with code 2: Couldn't posix_spawn: error 7
PackagingResults: Error: Archiving failed: metal-ar failed with code 2: Couldn't posix_spawn: error 7
PackagingResults: Error: Archiving failed: no valid input for metallib.
PackagingResults: Error: Archiving failed: no valid input for metallib.
PackagingResults: Error: Archiving failed: no valid input for metallib.
PackagingResults: Error: Package Native Shader Library failed for IOS.

引擎中调用metal-ar的代码如下：

感觉错误的问题像是传递给metal-ar的参数太长了导致的，把metal-ar参数打出来发现确实非常长：

解决办法，把在Mac上GetMaxArgLength的返回值改成一个较小的值或者从环境变量中获取即可：

Developer\Apple\MetalShaderFormat\Private\MetalShaderCompiler.cpp
1
2
3
4
5
6
7
8
9
10
11
static uint32 GetMaxArgLength()
{
#if PLATFORM_MAC && !UNIXLIKE_TO_MAC_REMOTE_BUILDING
  // 引擎中原始代码为返回ARG_MAX
  // return ARG_MAX;
  return 4096;
#else
  // Ask the remote machine via "getconf ARG_MAX"
  return 1024;
#endif
}

在官方版本的4.25.2中已经修复：Use runtime evaluation of ARG_MAX instead of the compile-time constant (which in Xcode 12 is now 1m)

Developer\Apple\MetalShaderFormat\Private\MetalShaderCompiler.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
static uint32 GetMaxArgLength()
{
#if PLATFORM_MAC && !UNIXLIKE_TO_MAC_REMOTE_BUILDING
    static uint32 MaxLength = 0;
    if (!MaxLength)
    {
        // It's dangerous to use "ARG_MAX" directly because it's a compile time constant and may not be compatible with the running OS.
        // It's safer to get the number from "getconf ARG_MAX" and only use the constant as the fallback
        FString StdOut, StdError;
        if (ExecRemoteProcess(TEXT("/usr/bin/getconf"), TEXT("ARG_MAX"), nullptr, &StdOut, &StdError))
        {
            MaxLength = FCString::Atoi(*StdOut);
            check(MaxLength > 0);
            UE_LOG(LogMetalShaderCompiler, Display, TEXT("Set MaxArgLength to %d via getconf"), MaxLength);
        }
        else
        {
            MaxLength = FMath::Min(ARG_MAX, 256 * 1024);
            UE_LOG(LogMetalShaderCompiler, Warning, TEXT("Failed to determine MaxArgLength via getconf: %s\nSet it to %d which is the lesser of MAX_ARG and the value from the 10.15 SDK"), *StdError, MaxLength);
        }
    }
    return MaxLength;
#else
    // Ask the remote machine via "getconf ARG_MAX"
    return 1024;
#endif
}

关闭UnityBuild

默认情况下，UE默认开启了bUseUnityBuild，会把多个cpp合并成一个翻译单元进行编译，加快项目的编译速度，编译时有*_1_of_8.cpp.obj等log。所以如果项目的头文件包含不规范，编译时头文件检测可能会出现问题：修改了A文件导致B文件出现错误。

所以，想在检测出中这种错误，可以关闭UnityBuild，使每个cpp都作为单独的翻译单元编译，有两种方法：

  1. 对整个工程（包含插件）关闭bUseUnityBuild，在项目的Target.cs中添加
target.cs
1
2
bForceUnityBuild = false;
bUseUnityBuild = false;

不修改代码，也可以在BuildCongiguration.xml中配置关闭：

1
2
3
4
5
6
7
8
9
10
11
12
13
/// <summary>
/// Whether to unify C++ code into larger files for faster compilation.
/// </summary>
[CommandLine("-DisableUnity", Value = "false")]
[XmlConfigFile(Category = "BuildConfiguration")]
public bool bUseUnityBuild = true;

/// <summary>
/// Whether to force C++ source files to be combined into larger files for faster compilation.
/// </summary>
[CommandLine("-ForceUnity")]
[XmlConfigFile(Category = "BuildConfiguration")]
public bool bForceUnityBuild = false;
  1. 对单个模块关闭UnityBuild，在Build.cs中关闭
1
bUseUnity = false;

可以在Target.cs中指定关闭UnityBuild的模块，也可以配置在BuildConfiguration.xml中：

1
2
3
4
5
/// <summary>
/// List of modules to disable unity builds for
/// </summary>
[XmlConfigFile(Category = "ModuleConfiguration", Name = "DisableUnityBuild")]
public string[] DisableUnityBuildForModules = null;

可以在Intermediate\Build\Win64\UE4Editor\Development\Client等路径下看到生成的大量.response文件。

TextureStreaming

Runtime\Engine\Private\Streaming\TextureStreamingHelpers.cpp
1
2
3
4
5
6
7
8
9
#if PLATFORM_SUPPORTS_TEXTURE_STREAMING
TAutoConsoleVariable<int32> CVarSetTextureStreaming(
  TEXT("r.TextureStreaming"),
  1,
  TEXT("Allows to define if texture streaming is enabled, can be changed at run time.\n")
  TEXT("0: off\n")
  TEXT("1: on (default)"),
  ECVF_Default | ECVF_RenderThreadSafe);
#endif

引擎中的默认配置：

Engine/Config/BaseScalability.ini
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
[TextureQuality@0]
; Must be used with r.streaming.usepertexturebias set to 1. Otherwise, all textures will have a constant 16 mip bias
r.Streaming.MipBias=16
r.Streaming.AmortizeCPUToGPUCopy=1
r.Streaming.MaxNumTexturesToStreamPerFrame=1
r.Streaming.Boost=0.3
r.MaxAnisotropy=0
r.VT.MaxAnisotropy=4
r.Streaming.LimitPoolSizeToVRAM=1
r.Streaming.PoolSize=400
r.Streaming.MaxEffectiveScreenSize=0

[TextureQuality@1]
r.Streaming.MipBias=1
r.Streaming.AmortizeCPUToGPUCopy=0
r.Streaming.MaxNumTexturesToStreamPerFrame=0
r.Streaming.Boost=1
r.MaxAnisotropy=2
r.VT.MaxAnisotropy=4
r.Streaming.LimitPoolSizeToVRAM=1
r.Streaming.PoolSize=600
r.Streaming.MaxEffectiveScreenSize=0

[TextureQuality@2]
r.Streaming.MipBias=0
r.Streaming.AmortizeCPUToGPUCopy=0
r.Streaming.MaxNumTexturesToStreamPerFrame=0
r.Streaming.Boost=1
r.MaxAnisotropy=4
r.VT.MaxAnisotropy=8
r.Streaming.LimitPoolSizeToVRAM=1
r.Streaming.PoolSize=800
r.Streaming.MaxEffectiveScreenSize=0

[TextureQuality@3]
r.Streaming.MipBias=0
r.Streaming.AmortizeCPUToGPUCopy=0
r.Streaming.MaxNumTexturesToStreamPerFrame=0
r.Streaming.Boost=1
r.MaxAnisotropy=8
r.VT.MaxAnisotropy=8
r.Streaming.LimitPoolSizeToVRAM=0
r.Streaming.PoolSize=1000
r.Streaming.MaxEffectiveScreenSize=0

[TextureQuality@Cine]
r.Streaming.MipBias=0
r.Streaming.AmortizeCPUToGPUCopy=0
r.Streaming.MaxNumTexturesToStreamPerFrame=0
r.Streaming.Boost=1
r.MaxAnisotropy=8
r.VT.MaxAnisotropy=8
r.Streaming.LimitPoolSizeToVRAM=0
r.Streaming.PoolSize=3000
r.Streaming.MaxEffectiveScreenSize=0

PackagePath获取资源磁盘路径

从/Game/Texture/TextureBG获取uasset在本地磁盘的路径。

1
2
3
4
5
6
7
8
FString LongPackageName = TEXT("/Game/Texture/TextureBG")
TArray<FAssetData> AssetsData;
FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
AssetRegistryModule.Get().GetAssetsByPackageName(*LongPackageName, AssetsData, true);
UPackage* Package = AssetsData[index].GetPackage();
FString AssetDiskPath;
const FString* PackageExtension = Package->ContainsMap() ? &FPackageName::GetMapPackageExtension() : &FPackageName::GetAssetPackageExtension();
FPackageName::TryConvertLongPackageNameToFilename(AssetsData[0].PackageName.ToString(), AssetDiskPath, *PackageExtension);

关闭PCH

在TargetRules.cs中有bUsePCHFiles和bUseSharedPCHs两个选项，可以控制项目是否开启PCH：

UnrealBuildTool\Configuration\TargetRules.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/// <summary>
/// Whether PCH files should be used.
/// </summary>
[CommandLine("-NoPCH", Value = "false")]
[XmlConfigFile(Category = "BuildConfiguration")]
public bool bUsePCHFiles = true;

/// <summary>
/// Enables "Shared PCHs", a feature which significantly speeds up compile times by attempting to
/// share certain PCH files between modules that UBT detects is including those PCH's header files.
/// </summary>
[CommandLine("-NoSharedPCH", Value = "false")]
[XmlConfigFile(Category = "BuildConfiguration")]
public bool bUseSharedPCHs = true;

但是为了不改动代码，也可以通过BuildConfiguration.xml中的设置：

1
2
C:\Users\lipengzha\AppData\Roaming\Unreal Engine\UnrealBuildTool\BuildConfiguration.xml
F:\EngineSource\UE_4.26\Engine\Saved\UnrealBuildTool\BuildConfiguration.xml

这两个路径下的均可，在Configuration下的BuildConfiguration中添加以下配置：

1
2
3
4
5
6
<Configuration xmlns="https://docs.unrealengine.com/4.26/en-US/ProductionPipelines/BuildTools/UnrealBuildTool/BuildConfiguration/">
  <BuildConfiguration>
    <bUsePCHFiles>true</bUsePCHFiles>
    <bUseSharedPCHs>false</bUseSharedPCHs>
  </BuildConfiguration>
</Configuration>

更多的参数可以在Build Configuration查看。

源码版与安装版IOS数据路径差异

使用安装版引擎打包IOS时，开启FileSharing能够在通过工具访问程序的Document目录，里面类似Android的UE4Game目录结构。
但是当使用源码版引擎打包时，开启FileSharing的包，UE的数据目录并不在Document目录下，因为项目配置没有任何更改，怀疑是引擎中有些地方对源码版或安装版做了检测。
搜索代码发现，引擎中通过FILESHARING_ENABLED宏进行检测，当开启时，数据目录位于Library目录下，没有开启时则位于Document目录下。

Core/Private/IOS/IOSPlatformMisc.cpp
1
2
3
4
5
6
7
8
9
10
void FIOSPlatformMisc::PlatformInit()
{
  // ...
#if FILESHARING_ENABLED
  FString DownloadPath = FString([NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES) objectAtIndex:0]) + TEXT("/");
#else
  FString DownloadPath = FString([NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0]) + TEXT("/");
#endif
  // ...
}

这个宏由UBT生成，通过读取DefaultEngine.ini中[/Script/IOSRuntimeSettings.IOSRuntimeSettings]下的bSupportsITunesFileSharing来确定宏的值。

Source/Programs/UnrealBuildTool/Platform/IOS/UEBuildIOS.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/// <summary>
/// Stores project-specific IOS settings. Instances of this object are cached by IOSPlatform.
/// </summary>
public class IOSProjectSettings
{
  // ...
  /// <summary>
  /// true if iTunes file sharing support is enabled
  /// </summary>
  [ConfigFile(ConfigHierarchyType.Engine, "/Script/IOSRuntimeSettings.IOSRuntimeSettings", "bSupportsITunesFileSharing")]
  public readonly bool bFileSharingEnabled = false;
  // ...
}

添加宏的代码如下：

Source/Programs/UnrealBuildTool/Platform/IOS/UEBuildIOS.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/// <summary>
/// Setup the target environment for building
/// </summary>
/// <param name="Target">Settings for the target being compiled</param>
/// <param name="CompileEnvironment">The compile environment for this target</param>
/// <param name="LinkEnvironment">The link environment for this target</param>
public override void SetUpEnvironment(ReadOnlyTargetRules Target, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment)
{
  // ...
  if (ProjectSettings.bFileSharingEnabled)
  {
    CompileEnvironment.Definitions.Add("FILESHARING_ENABLED=1");
  }
  else
  {
    CompileEnvironment.Definitions.Add("FILESHARING_ENABLED=0");
  }
  // ...
}

原因分析：

  1. 因为编译安装版引擎时，没有项目，引擎中BaseEngine.ini中bSupportsITunesFileSharing=False，所以通过BuildGraph编译安装版引擎时，bFileSharingEnabled默认值是false，通过安装版引擎打包项目引擎也不会编译了，所以bFileSharingEnabled的值一直是false，使用的是NSDocumentDirectory目录
  2. 相同的道理，使用源码版引擎打包项目时，因为需要通过打包项目才编译引擎，如果项目中指定了bSupportsITunesFileSharing=True，则编译引擎时bFileSharingEnabled就为true，导致FILESHARING_ENABLED=1，则使用了NSLibraryDirectory目录。

需要注意的是：bSupportsITunesFileSharing不仅仅只是控制数据存储路径，还控制打包时plist的生成：

Programs/UnrealBuildTool/Platform/IOS/UEDeployIOS.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static bool GenerateIOSPList(FileReference ProjectFile, UnrealTargetConfiguration Config, string ProjectDirectory, bool bIsUE4Game, string GameName, bool bIsClient, string ProjectName, string InEngineDir, string AppDirectory, VersionNumber SdkVersion, UnrealPluginLanguage UPL, string BundleID, bool bBuildAsFramework, out bool bSupportsPortrait, out bool bSupportsLandscape, out bool bSkipIcons)
{
  // ITunes file sharing
  bool bSupportsITunesFileSharing = false;
  Ini.GetBool("/Script/IOSRuntimeSettings.IOSRuntimeSettings", "bSupportsITunesFileSharing", out bSupportsITunesFileSharing);
  bool bSupportsFilesApp = false;
  Ini.GetBool("/Script/IOSRuntimeSettings.IOSRuntimeSettings", "bSupportsFilesApp", out bSupportsFilesApp);

  // ...

  Text.AppendLine("\t<key>UIFileSharingEnabled</key>");
  Text.AppendLine(string.Format("\t<{0}/>", bSupportsITunesFileSharing ? "true" : "false"));
  if (bSupportsFilesApp)
  {
    Text.AppendLine("\t<key>LSSupportsOpeningDocumentsInPlace</key>");
    Text.AppendLine("\t<true/>");
  }
  // ...
}

所以，为了同时支持数据存储在Document下和开启plist中的UIFileSharingEnabled，对于FileSharing功能的支持需要进行以下操作：

  1. DefaultEngine.ini中的bSupportsITunesFileSharing=False
  2. 修改引擎中生成FILESHARING_ENABLED宏的代码，保持为false即可

Viveport选中Actor按F调用函数

在编辑器中选中一个Actor，按F键，当前的编辑器视口会移动到Actor，调用的是这些函数：

Editor\UnrealEd\Classes\Editor\EditorEngine.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
* Moves all viewport cameras to the target actor.
* @param  Actor         Target actor.
* @param  bActiveViewportOnly   If true, move/reorient only the active viewport.
*/
void MoveViewportCamerasToActor(AActor& Actor,  bool bActiveViewportOnly);

/**
* Moves all viewport cameras to focus on the provided array of actors.
* @param  Actors          Target actors.

* @param  bActiveViewportOnly   If true, move/reorient only the active viewport.
*/
void MoveViewportCamerasToActor(const TArray<AActor*> &Actors, bool bActiveViewportOnly);

/**
* Moves all viewport cameras to focus on the provided array of actors.
* @param  Actors          Target actors.
* @param  Components        Target components (used of actors array is empty)
* @param  bActiveViewportOnly   If true, move/reorient only the active viewport.
*/
void MoveViewportCamerasToActor(const TArray<AActor*> &Actors, const TArray<UPrimitiveComponent*>& Components, bool bActiveViewportOnly);

Searchable Names

在UE的资源依赖关系中，除了Hard/Soft之外，还有一种Searchable Name，排查之后发现GamePlayTag标记的是SearchableName的类型：


因为在C++中加载资源是直接指定路径的，所以在想有没有一种办法，通过C++加载，也可以分析出代码中加载资源的依赖关系，作为一种思路，先记录一下。

基础包过滤config中的ini文件

打包时会有以下Log：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
UATHelper: Packaging (Windows (64-bit)): Creating Staging Manifest...
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\BaseEditor.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\BaseEditorKeyBindings.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\BaseEditorPerProjectUserSettings.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\BaseEditorSettings.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\BaseLightmass.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\BasePakFileRules.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\Localization\Category.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\Localization\Editor.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\Localization\EditorTutorials.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\Localization\Engine.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\Localization\Keywords.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\Localization\PortableObjectExport.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\Localization\PortableObjectImport.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\Localization\PropertyNames.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\Localization\RepairData.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\Localization\ToolTips.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\build_agent\workspace\FGameEngine\Engine\Engine\Config\Localization\WordCount.ini
UATHelper: Packaging (Windows (64-bit)): WARNING: The config file 'FGame/Config/DefaultAssetTags.ini' will be staged, but is not whitelisted or blacklisted. Add +WhitelistConfigFiles=FGame/Config/DefaultAssetTags.ini or +BlacklistConfigFiles=FGame/Config/DefaultAssetTags.ini to the [Staging] section of DefaultGame.ini
UATHelper: Packaging (Windows (64-bit)): Excluding config file C:\Users\lipengzha\Documents\UnrealProjects\Client\Config\DefaultEditor.ini
UATHelper: Packaging (Windows (64-bit)): Cleaning Stage Directory: C:\Users\lipengzha\Documents\UnrealProjects\Client\Saved\StagedBuilds\WindowsNoEditor

根据上面的提示，可以在DefaultGame.ini中通过设置[Staging]中的值来控制白名单与黑名单：

1
2
3
[Staging]
+WhitelistConfigFiles=FGame/Config/DefaultAssetTags.ini
+BlacklistConfigFiles=FGame/Config/DefaultAssetTags.ini

引擎中打包时有一个默认的规则，代码如下：

Source\Programs\AutomationTool\Scripts\CopyBuildToStagingDirectory.Automation.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
/// <summary>
/// Determines if an individual config file should be staged
/// </summary>
/// <param name="SC">The staging context</param>
/// <param name="ConfigDir">Directory containing the config files</param>
/// <param name="ConfigFile">The config file to check</param>
/// <returns>True if the file should be staged, false otherwise</returns>
static Nullable < bool > ShouldStageConfigFile(DeploymentContext SC, DirectoryReference ConfigDir, FileReference ConfigFile, string PlatformExtensionName) {
  StagedFileReference StagedConfigFile = SC.GetStagedFileLocation(ConfigFile);
  if (SC.WhitelistConfigFiles.Contains(StagedConfigFile)) {
    return true;
  }
  if (SC.BlacklistConfigFiles.Contains(StagedConfigFile)) {
    return false;
  }

  string NormalizedPath = ConfigFile.MakeRelativeTo(ConfigDir).ToLowerInvariant().Replace('\\', '/');

  int DirectoryIdx = NormalizedPath.IndexOf('/');
  if (DirectoryIdx == -1) {
    const string BasePrefix = "base";
    if (NormalizedPath.StartsWith(BasePrefix)) {
      string ShortName = NormalizedPath.Substring(BasePrefix.Length);
      if (PlatformExtensionName != null) {
        if (!ShortName.StartsWith(PlatformExtensionName, StringComparison.InvariantCultureIgnoreCase)) {
          // Ignore config files in the platform directory that don't start with the platform name.
          return false;
        }

        ShortName = ShortName.Substring(PlatformExtensionName.Length);
      }

      return ShouldStageConfigSuffix(SC, ConfigFile, ShortName);
    }

    const string DefaultPrefix = "default";
    if (NormalizedPath.StartsWith(DefaultPrefix)) {
      string ShortName = NormalizedPath.Substring(DefaultPrefix.Length);
      if (PlatformExtensionName != null) {
        if (!ShortName.StartsWith(PlatformExtensionName, StringComparison.InvariantCultureIgnoreCase)) {
          // Ignore config files in the platform directory that don't start with the platform name.
          return false;
        }

        ShortName = ShortName.Substring(PlatformExtensionName.Length);
      }

      return ShouldStageConfigSuffix(SC, ConfigFile, ShortName);
    }

    const string DedicatedServerPrefix = "dedicatedserver";
    if (NormalizedPath.StartsWith(DedicatedServerPrefix)) {
      return SC.DedicatedServer ? ShouldStageConfigSuffix(SC, ConfigFile, NormalizedPath.Substring(DedicatedServerPrefix.Length)) : false;
    }

    if (NormalizedPath == "consolevariables.ini") {
      return SC.StageTargetConfigurations.Any(x = >x != UnrealTargetConfiguration.Test && x != UnrealTargetConfiguration.Shipping);
    }

    if (NormalizedPath == "locgatherconfig.ini") {
      return false;
    }

    if (NormalizedPath == "designertoolsconfig.ini") {
      return false;
    }

    if (PlatformExtensionName != null) {
      if (NormalizedPath.StartsWith(PlatformExtensionName, StringComparison.InvariantCultureIgnoreCase)) {
        string ShortName = NormalizedPath.Substring(PlatformExtensionName.Length);
        return ShouldStageConfigSuffix(SC, ConfigFile, ShortName);
      }

      if (NormalizedPath == "datadrivenplatforminfo.ini") {
        return true;
      }
    }
  }
  else {
    if (NormalizedPath.StartsWith("layouts/")) {
      return true;
    }

    if (NormalizedPath.StartsWith("localization/")) {
      return false;
    }

    string PlatformPrefix = String.Format("{0}/{0}", NormalizedPath.Substring(0, DirectoryIdx));
    if (NormalizedPath.StartsWith(PlatformPrefix)) {
      return ShouldStageConfigSuffix(SC, ConfigFile, NormalizedPath.Substring(PlatformPrefix.Length));
    }

    string PlatformBasePrefix = String.Format("{0}/base{0}", NormalizedPath.Substring(0, DirectoryIdx));
    if (NormalizedPath.StartsWith(PlatformBasePrefix)) {
      return ShouldStageConfigSuffix(SC, ConfigFile, NormalizedPath.Substring(PlatformBasePrefix.Length));
    }

    if (NormalizedPath.EndsWith("/datadrivenplatforminfo.ini")) {
      return true;
    }

  }
  return null;
}

/// <summary>
/// Determines if the given config file suffix ("engine", "game", etc...) should be staged for the given context.
/// </summary>
/// <param name="SC">The staging context</param>
/// <param name="ConfigFile">Full path to the config file</param>
/// <param name="InvariantSuffix">Suffix for the config file, as a lowercase invariant string</param>
/// <returns>True if the suffix should be staged, false if not, null if unknown</returns>
static Nullable < bool > ShouldStageConfigSuffix(DeploymentContext SC, FileReference ConfigFile, string InvariantSuffix) {
  switch (InvariantSuffix) {
  case ".ini":
  case "compat.ini":
  case "deviceprofiles.ini":
  case "engine.ini":
  case "enginechunkoverrides.ini":
  case "game.ini":
  case "gameplaytags.ini":
  case "gameusersettings.ini":
  case "hardware.ini":
  case "input.ini":
  case "scalability.ini":
  case "runtimeoptions.ini":
  case "installbundle.ini":
    return true;
  case "crypto.ini":
  case "editor.ini":
  case "editorgameagnostic.ini":
  case "editorkeybindings.ini":
  case "editorlayout.ini":
  case "editorperprojectusersettings.ini":
  case "editorsettings.ini":
  case "editorusersettings.ini":
  case "lightmass.ini":
  case "pakfilerules.ini":
    return false;
  default:
    return null;
  }
}

t.MaxFPS启动时无效

之前在游戏启动时设置锁帧：

DefaultEngine.ini
1
2
[ConsoleVariables]
t.MaxFPS=30

但是发现在目前的引擎版本无效了，从Log里看出来确实从配置中读取了这个值，但是游戏中帧率无变化，所以猜测是哪里又把帧率给改了。

调试后发现，引擎启动时从GameUserSetting读取并执行了SetMaxFPS：

所以，正确的办法是设置DefaultGameUserSettings.ini里的FrameRateLimit值：

DefaultGameUserSettings.ini
1
2
[/Script/Engine.GameUserSettings]
FrameRateLimit=30

如果写在DefaultGameUserSetting.ini中，无论是编辑器或者任何打包的平台，默认都是锁帧，如果想要针对某个平台锁帧，可以将其写到特定平台的*GameUserSettings.ini中：

1
2
3
Config/Android/AndroidGameUserSettings.ini
Config/IOS/IOSGameUserSettings.ini
Config/Windows/WindowsGameUserSettings.ini

UE执行py的Commandlet

把Py脚本放入Content/Python下，使用Commandlet的形式执行以下命令：

1
UE4Editor-cmd.exe PROJECT.uproject -run=pythonscript -script=NavMeshExporter.py

一个脚本例子：

1
2
3
4
5
import unreal
import sys

if __name__ == '__main__':
  do_something()

设置ConsoleVariables值的几种方式

  1. 修改引擎Config/ConsoleVariables.ini
  2. 修改引擎(BaseEngine.ini)/项目(DefaultEngine.ini)中的[SystemSettings]
  3. 运行时console输入
  4. 编辑Device Profiles

运行时通过FConsoleManager获取/修改：

1
2
IConsoleVariable* CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Shadow.MinResolution"));
CVar->Set(16, SetBy);

Set有几个重载:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/** Set the internal value from the specified bool. */
void Set(bool InValue, EConsoleVariableFlags SetBy = ECVF_SetByCode)
{
  // NOTE: Bool needs to use 1 and 0 here rather than true/false, as this may be a int32 or something
  // and eventually this code calls, TTypeFromString<T>::FromString which won't handle the true/false,
  // but 1 and 0 will work for whatever.
  // inefficient but no common code path
  Set(InValue ? TEXT("1") : TEXT("0"), SetBy);
}
/** Set the internal value from the specified int. */
void Set(int32 InValue, EConsoleVariableFlags SetBy = ECVF_SetByCode)
{
  // inefficient but no common code path
  Set(*FString::Printf(TEXT("%d"), InValue), SetBy);
}
/** Set the internal value from the specified float. */
void Set(float InValue, EConsoleVariableFlags SetBy = ECVF_SetByCode)
{
  // inefficient but no common code path
  Set(*FString::Printf(TEXT("%g"), InValue), SetBy);
}

第二个参数为EConsoleVariableFlags：

HAL/IConsoleManager.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
enum EConsoleVariableFlags
{
    ECVF_FlagMask                    = 0x0000ffff,
    ECVF_Default                     = 0x0,
    ECVF_Cheat                       = 0x1,
    ECVF_ReadOnly                    = 0x4,
    ECVF_Unregistered                = 0x8,
    ECVF_CreatedFromIni              = 0x10,
    ECVF_RenderThreadSafe            = 0x20,
    ECVF_Scalability                 = 0x40,
    ECVF_ScalabilityGroup            = 0x80,
    ECVF_SetFlagMask                 = 0x00ff0000,
    ECVF_Set_NoSinkCall_Unsafe       = 0x00010000,
    ECVF_SetByMask                   = 0xff000000,
    ECVF_SetByConstructor            = 0x00000000,
    ECVF_SetByScalability            = 0x01000000,
    ECVF_SetByGameSetting            = 0x02000000,
    ECVF_SetByProjectSetting         = 0x03000000,
    ECVF_SetBySystemSettingsIni      = 0x04000000,
    ECVF_SetByDeviceProfile          = 0x05000000,
    ECVF_SetByConsoleVariablesIni    = 0x06000000,
    ECVF_SetByCommandline            = 0x07000000,
    ECVF_SetByCode                   = 0x08000000,
    ECVF_SetByConsole                = 0x09000000,
}

debug shader compile

1
2
3
4
5
6
7
8
9
10
[Startup]
; Uncomment to get detailed logs on shader compiles and the opportunity to retry on errors
r.ShaderDevelopmentMode=1
; Uncomment to dump shaders in the Saved folder (1 dump all, 2 dump on compilation failure only, 3 dump on compilation failure or warnings)
; Warning: leaving this on for a while will fill your hard drive with many small files and folders
r.DumpShaderDebugInfo=1
; When this is enabled, dumped shader paths will get collapsed (in the cases where paths are longer than the OS's max)
r.DumpShaderDebugShortNames=1
; When this is enabled, when dumping shaders an additional file to use with ShaderCompilerWorker -direct mode will be generated
r.DumpShaderDebugWorkerCommandLine=1

移动平台纹理压缩格式

Android有ETC1/ETC2/ASTC。
IOS有ASTC/PVRTC，ASTC从A8开始支持。

控制打包的log level

在非shipping模式下可以通过-LogCmds指定:

1
-LogCmds="global Verbose, LogPython Verbose, LogAnimMontage off, LogDeepDriveAgent VeryVerbose"

也可以在DefaultEngine.ini中进行控制：

DefaultEngine.ini
1
2
3
4
[Core.Log]
global=[default verbosity for things not listed later]
[cat]=[level]
foo=verbose break

配置参数的使用:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
------- Log conventions
[cat]   = a category for the command to operate on, or 'global' for all categories.
[level] = verbosity level, one of: none, error, warning, display, log, verbose, all, default
At boot time, compiled in default is overridden by ini files setting, which is overridden by command line
------- Log console command usage
Log list            - list all log categories
Log list [string]   - list all log categories containing a substring
Log reset           - reset all log categories to their boot-time default
Log [cat]           - toggle the display of the category [cat]
Log [cat] off       - disable display of the category [cat]
Log [cat] on        - resume display of the category [cat]
Log [cat] only      - enables [cat] and disables all other categories"));
Log [cat] [level]   - set the verbosity level of the category [cat]
Log [cat] break     - toggle the debug break on display of the category [cat]
------- Log command line
-LogCmds=\"[arguments],[arguments]...\"           - applies a list of console commands at boot time
-LogCmds=\"foo verbose, bar off\"         - turns on the foo category and turns off the bar category          
------- Environment variables
Any command line option can be set via the environment variable UE-CmdLineArgs
set UE-CmdLineArgs=\"-LogCmds=foo verbose breakon, bar off\"
------- Config file
[Core.Log]
global=[default verbosity for things not listed later]          
[cat]=[level]         
foo=verbose break

以下为参考配置，使用LogCategory=LogLevel这种方式进行设置，在游戏运行时会自动读取：

1
2
3
4
5
6
7
8
9
[Core.Log]
LogInit=warning
LogTaskGraph=warning
LogDevObjectVersion=warning
LogMemory=warning
LogTextLocalizationManager=warning
LogObj=warning
LogExit=warning
LogPlatformFile=warning

使用[Core.Log]与-LogCmds在非shipping模式下在相同的执行流程了，在Shipping打包时-LogCmds的支持就被剔除了。

具体代码在FLogSuppressionImplementation::ProcessConfigAndCommandLine函数里：Logging/LogSuppressionInterface.cpp#L479

修改PCH Buffer size

默认是/Zm1000，就是750M，如果编译时产生页面文件太小的错误：

1
2
3
4
c1xx: error C3859: Failed to create virtual memory for PCH
c1xx: note: the system returned code 1455: 页面文件太小，无法完成操作。
c1xx: note: please visit https://aka.ms/pch-help for more details
c1xx: fatal error C1076: compiler limit: internal heap limit reached

可以在项目的target.cs里添加以下代码：

1
2
3
4
5
if(Target.Platform == UnrealTargetPlatform.Win64)
{
  bOverrideBuildEnvironment = true;
  AdditionalCompilerArguments = "/Zm2000";
}

PSO Caching配置

在Runtime\RenderCore\Private\ShaderPipelineCache.cpp中，定义了一批与PSO相关的ConsoleVariable对象，可以使用以下配置或者Console指定来使用：

DefaultEngine.ini
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
[ConsoleVariables]
;Sets the startup mode for the PSO cache, determining what the cache does after initialisation:
;0: Precompilation is paused and nothing will compile until a call to ResumeBatching().
;1: Precompilation is enabled in the 'Fast' mode.
;2: Precompilation is enabled in the 'Background' mode.
;Default is 1.
r.ShaderPipelineCache.StartupMode=1

;Set the number of PipelineStateObjects to compile in a single batch operation when compiling takes priority. Defaults to a maximum of 50 per frame, due to async. file IO it is less in practice.
r.ShaderPipelineCache.BackgroundBatchSize=1

;Set the number of PipelineStateObjects to compile in a single batch operation when pre-optimizing the cache. Defaults to a maximum of 50 per frame, due to async. file IO it is less in practice.
r.ShaderPipelineCache.PrecompileBatchSize=50

;The target time (in ms) to spend precompiling each frame when in the background or 0.0 to disable. When precompiling is faster the batch size will grow and when slower will shrink to attempt to occupy the full amount. Defaults to 0.0 (off).
r.ShaderPipelineCache.BackgroundBatchTime=0.0

;The target time (in ms) to spend precompiling each frame when compiling takes priority or 0.0 to disable. When precompiling is faster the batch size will grow and when slower will shrink to attempt to occupy the full amount. Defaults to 16.0 (max. ms per-frame of precompilation).
r.ShaderPipelineCache.BatchTime=16.0

;The target time (in ms) to spend precompiling each frame when cpre-optimizing or 0.0 to disable. When precompiling is faster the batch size will grow and when slower will shrink to attempt to occupy the full amount. Defaults to 10.0 (off).
r.ShaderPipelineCache.PrecompileBatchTime=0.0

;Set the number of PipelineStateObjects to log before automatically saving. 0 will disable automatic saving. Shipping defaults to 0, otherwise default is 100.
r.ShaderPipelineCache.SaveAfterPSOsLogged=100

;Set the time where any logged PSO's will be saved if the number is < r.ShaderPipelineCache.SaveAfterPSOsLogged. Disabled when r.ShaderPipelineCache.SaveAfterPSOsLogged is 0

;Set the time where any logged PSO's will be saved if the number is < r.ShaderPipelineCache.SaveAfterPSOsLogged. Disabled when r.ShaderPipelineCache.SaveAfterPSOsLogged is 0
r.ShaderPipelineCache.AutoSaveTime=30

;Mask used to precompile the cache. Defaults to all PSOs (-1)
r.ShaderPipelineCache.PreCompileMask=-1

;Set the time where any logged PSO's will be saved when -logpso is on the command line.
r.ShaderPipelineCache.AutoSaveTimeBoundPSO=10

;If > 0 then a log of all bound PSOs for this run of the program will be saved to a writable user cache file. Defaults to 0 but is forced on with -logpso.
r.ShaderPipelineCache.SaveBoundPSOLog=0

;Set non zero to use GameFileMask during PSO precompile - recording should always save out the usage masks to make that data availble when needed.
r.ShaderPipelineCache.GameFileMaskEnabled=0

;Set non zero to PreOptimize PSOs - this allows some PSOs to be compiled in the foreground before going in to game
r.ShaderPipelineCache.PreOptimizeEnabled=0

;The minimum bind count to allow a PSO to be precompiled.  Changes to this value will not affect PSOs that have already been removed from consideration.
r.ShaderPipelineCache.MinBindCount=0

;The maximum time to allow a PSO to be precompiled.  if greather than 0, the amount of wall time we will allow pre-compile of PSOs and then switch to background processing.
r.ShaderPipelineCache.MaxPrecompileTime=0.0

DefaultGameUserSettings.ini:

1
2
3
4
5
6
[ShaderPipelineCache.CacheFile]
;default is 0
;Default = 0, // Whatever order they are already in.
;FirstToLatestUsed = 1, // Start with the PSOs with the lowest first-frame used and work toward those with the highest.
;MostToLeastUsed = 2 // Start with the most often used PSOs working toward the least.
SortOrder=1

MacSDK下载

清理Mac DDC

删除以下三个目录：

1
2
3
rm -rf Engine/DerivedDataCache
rm -rf /Users/buildmachine/Library/Application\ Support/Epic/UnrealEngine
rm -rf Client/DerivedDataCache

修改平台使用的RHI

前面的笔记中提到了再Win上可以通过-FeatureLevelES31来指定Standalone模式使用ES3.1的RHI，但是打包时不能简单地这么指定，因为打包之后shaderbytecode都编译完了，SM5和ES3.1不通用，会提示Shader加载错误。

可以通过以下方式设置：

DefaultEngine.ini
1
2
3
4
5
6
[/Script/WindowsTargetPlatform.WindowsTargetSettings]
Compiler=Default
-TargetedRHIs=PCD3D_SM5
+TargetedRHIs=PCD3D_ES31
+TargetedRHIs=PCD3D_SM5
DefaultGraphicsRHI=DefaultGraphicsRHI_Default

该配置在以下代码中使用，代码篇幅太长，可从github上查看：Runtime/RHI/Private/Windows/WindowsDynamicRHI.cpp#L49。

Runtime/RHI/Private/Windows/WindowsDynamicRHI.cpp
1
static IDynamicRHIModule* LoadDynamicRHIModule(ERHIFeatureLevel::Type& DesiredFeatureLevel, const TCHAR*& LoadedRHIModuleName);

修改了之后重新打包，再通过-FeatureLevelES31指定即可启动ES3.1，不加默认则是SM5。

拆开pak可以看到，同时支持了SM5和ES31的Windows包内的ShaderCache和ushaderbytecode都包含了两份：

1
2
3
4
5
6
"D:\ES31ForWin\Saved\Cooked\WindowsNoEditor\Engine\GlobalShaderCache-PCD3D_ES31.bin" "../../../Engine/GlobalShaderCache-PCD3D_ES31.bin"
"D:\ES31ForWin\Saved\Cooked\WindowsNoEditor\Engine\GlobalShaderCache-PCD3D_SM5.bin" "../../../Engine/GlobalShaderCache-PCD3D_SM5.bin"
"D:\ES31ForWin\Saved\Cooked\WindowsNoEditor\ES31ForWin\Content\ShaderArchive-Global-PCD3D_ES31.ushaderbytecode" "../../../ES31ForWin/Content/ShaderArchive-Global-PCD3D_ES31.ushaderbytecode"
"D:\ES31ForWin\Saved\Cooked\WindowsNoEditor\ES31ForWin\Content\ShaderArchive-Global-PCD3D_SM5.ushaderbytecode" "../../../ES31ForWin/Content/ShaderArchive-Global-PCD3D_SM5.ushaderbytecode"
"D:\ES31ForWin\Saved\Cooked\WindowsNoEditor\ES31ForWin\Content\ShaderArchive-ES31ForWin-PCD3D_ES31.ushaderbytecode" "../../../ES31ForWin/Content/ShaderArchive-ES31ForWin-PCD3D_ES31.ushaderbytecode"
"D:\ES31ForWin\Saved\Cooked\WindowsNoEditor\ES31ForWin\Content\ShaderArchive-ES31ForWin-PCD3D_SM5.ushaderbytecode" "../../../ES31ForWin/Content/ShaderArchive-ES31ForWin-PCD3D_SM5.ushaderbytecode"

相关资料：

修改DDC的路径

源码版与安装版引擎的路径有区别：

BaseEngine.ini
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[DerivedDataBackendGraph_Fill_Seattle]
MinimumDaysToKeepFile=7
Root=(Type=KeyLength, Length=120, Inner=AsyncPut)
AsyncPut=(Type=AsyncPut, Inner=Hierarchy)
Hierarchy=(Type=Hierarchical, Inner=Boot, Inner=Pak, Inner=EnginePak, Inner=Local, Inner=Seattle)
Boot=(Type=Boot, Filename="%GAMEDIR%DerivedDataCache/Boot.ddc", MaxCacheSize=512)
Local=(Type=FileSystem, ReadOnly=false, Clean=false, Flush=false, PurgeTransient=true, DeleteUnused=true, UnusedFileAge=34, FoldersToClean=-1, Path=%ENGINEDIR%DerivedDataCache)
Seattle=(Type=FileSystem, ReadOnly=false, Clean=false, Flush=false, DeleteUnused=true, UnusedFileAge=23, FoldersToClean=10, MaxFileChecksPerSec=1, Path=?EpicSeaDDC, EnvPathOverride=UE-SharedDataCachePath_Seattle)
Pak=(Type=ReadPak, Filename="%GAMEDIR%DerivedDataCache/DDC.ddp")
EnginePak=(Type=ReadPak, Filename=%ENGINEDIR%DerivedDataCache/DDC.ddp)

[InstalledDerivedDataBackendGraph]
MinimumDaysToKeepFile=7
Root=(Type=KeyLength, Length=120, Inner=AsyncPut)
AsyncPut=(Type=AsyncPut, Inner=Hierarchy)
Hierarchy=(Type=Hierarchical, Inner=Boot, Inner=Pak, Inner=CompressedPak, Inner=EnginePak, Inner=EnterprisePak, Inner=Local, Inner=Shared)
Boot=(Type=Boot, Filename="%ENGINEUSERDIR%DerivedDataCache/Boot.ddc", MaxCacheSize=512)
Local=(Type=FileSystem, ReadOnly=false, Clean=false, Flush=false, PurgeTransient=true, DeleteUnused=true, UnusedFileAge=34, FoldersToClean=-1, Path="%ENGINEVERSIONAGNOSTICUSERDIR%DerivedDataCache", EditorOverrideSetting=LocalDerivedDataCache)
Shared=(Type=FileSystem, ReadOnly=false, Clean=false, Flush=false, DeleteUnused=true, UnusedFileAge=10, FoldersToClean=10, MaxFileChecksPerSec=1, Path=?EpicDDC, EnvPathOverride=UE-SharedDataCachePath, EditorOverrideSetting=SharedDerivedDataCache)
Pak=(Type=ReadPak, Filename="%GAMEDIR%DerivedDataCache/DDC.ddp")
CompressedPak=(Type=ReadPak, Filename="%GAMEDIR%DerivedDataCache/Compressed.ddp", Compressed=true)
EnginePak=(Type=ReadPak, Filename=../../../Engine/DerivedDataCache/Compressed.ddp, Compressed=true)
EnterprisePak=(Type=ReadPak, Filename=../../../Enterprise/DerivedDataCache/Compressed.ddp, Compressed=true)

源码版的引擎存在于Engine/DerivedDataCache与项目的DerivedDataCache目录下。
安装版引擎的则位于以下几个路径中：

  • %ENGINEUSERDIR%DerivedDataCache/Boot.ddc
  • %ENGINEVERSIONAGNOSTICUSERDIR%DerivedDataCache
  • %GAMEDIR%DerivedDataCache/DDC.ddp
  • ../../../Engine/DerivedDataCache/Compressed.ddp
  • ../../../Enterprise/DerivedDataCache/Compressed.ddp

这几个路径规则的真实路径：

Runtime/Core/Private/Misc/ConfigCacheIni.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
static const FConfigExpansion* MatchExpansions(const TCHAR* PotentialVariable)
{
  // Allocate replacement value strings once
  static const FConfigExpansion Expansions[] =
  {
    FConfigExpansion(TEXT("%GAME%"), FString(FApp::GetProjectName())),
    FConfigExpansion(TEXT("%GAMEDIR%"), FPaths::ProjectDir()),
    FConfigExpansion(TEXT("%ENGINEDIR%"), FPaths::EngineDir()),
    FConfigExpansion(TEXT("%ENGINEUSERDIR%"), FPaths::EngineUserDir()),
    FConfigExpansion(TEXT("%ENGINEVERSIONAGNOSTICUSERDIR%"), FPaths::EngineVersionAgnosticUserDir()),
    FConfigExpansion(TEXT("%APPSETTINGSDIR%"), GetApplicationSettingsDirNormalized()),
  };
    // ...
}

可以在BaseEngine.ini中修改DDC的路径占位符，替换为上面的可选路径。

注意：EngineUserDir与EngineVersionAgnosticUserDir在安装版与源码版上也有区分：

Runtime/Core/Private/Misc/Paths.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
FString FPaths::EngineUserDir()
{
  if (ShouldSaveToUserDir() || FApp::IsEngineInstalled())
  {
    return FPaths::Combine(FPlatformProcess::UserSettingsDir(), *FApp::GetEpicProductIdentifier(), *FEngineVersion::Current().ToString(EVersionComponent::Minor)) + TEXT("/");
  }
  else
  {
    return FPaths::EngineDir();
  }
}

FString FPaths::EngineVersionAgnosticUserDir()
{
  if (ShouldSaveToUserDir() || FApp::IsEngineInstalled())
  {
    return FPaths::Combine(FPlatformProcess::UserSettingsDir(), *FApp::GetEpicProductIdentifier(), TEXT("Common")) + TEXT("/");
  }
  else
  {
    return FPaths::EngineDir();
  }
}

默认情况下，如果要完全清理系统中的DDC缓存，需要清理以下路径：

1
2
3
Engine\Engine\DerivedDataCache\*
ProjectName\DerivedDataCache\*
C:\Users\username\AppData\Local\UnrealEngine\*

可以使用以下cmd命令：

1
2
3
echo y|del Engine\DerivedDataCache
echo y|del ProjectName\DerivedDataCache
echo y|del C:\Users\username\AppData\Local\UnrealEngine

类似问题：

App版本号

IOS

在IOS包的plist中可以通过控制以下两个值：

1
2
3
4
<key>CFBundleShortVersionString</key>
<string>1.0</string>
<key>CFBundleVersion</key>
<string>0.1</string>

一般使用CFBundleVersion来作为游戏版本号，在UE中可以通过UPL来控制plist。

Android

Android通过控制以下值：

1
2
3
[/Script/AndroidRuntimeSettings.AndroidRuntimeSettings]
VersionDisplayName=1.0.0
StoreVersion=1

Standalone模式的ES3预览

在启动时加入参数-FeatureLevelES31，在启动时就会由PCD3D_SM5变为PCD3D_ES31了。

修改引擎的编译器参数

如果想要在编译引擎时自定义加一些编译器参数可以修改Programs\UnrealBuildTool\Platform下各个平台的*Toolchain.cs中的：

1
2
3
4
5
6
string GetCompileArguments_Global(CppCompileEnvironment CompileEnvironment)
{
  // ++[RSTUDIO][lipengzha] support xcode12
  Result += " -Wno-range-loop-analysis";
  // --[RSTUDIO]
}

这是全局配置，如果想要给某个Target添加编译器参数可以在target.cs里通过AdditionalCompilerArguments设置：

1
2
bOverrideBuildEnvironment = true;
AdditionalCompilerArguments = "-Wno-range-loop-analysis";

独立半透明

有些半透明效果不希望受到景深的影响，可以开启独立半透明。

1
2
[/Script/Engine.RendererSettings]
r.SeparateTranslucency=False

但是项目中遇到在IOS上开启时有些特效层级会显示在人物和场景前面。

Slate图片

在Slate中可以使用FSlateIcon同通过指定名字(ContentBrowser.AssetActions)来指定使用UE中的图片资源，如：

1
2
3
4
5
6
7
8
9
10
11
12
13
// Asset Actions sub-menu
Section.AddSubMenu(
    "CookActionsSubMenu",
    LOCTEXT("CookActionsSubMenuLabel", "Cook Actions"),
    LOCTEXT("CookActionsSubMenuToolTip", "Cook actions"),
    FNewToolMenuDelegate::CreateRaw(this, &FHotPatcherEditorModule::MakeCookActionsSubMenu),
    FUIAction(
        FExecuteAction()
        ),
    EUserInterfaceActionType::Button,
    false, 
    FSlateIcon(FEditorStyle::GetStyleSetName(), "ContentBrowser.AssetActions")
    );

那么名字(ContentBrowser.AssetActions)与真实的图片是如何对应起来的呢？

在Editor\EditorStyle\Private\SlateEditorStyle.cpp文件中定义了这些名字与图片的映射：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Set( "ContentBrowser.AssetActions", new IMAGE_BRUSH( "Icons/icon_tab_Tools_16x", Icon16x16 ) );
Set( "ContentBrowser.AssetActions.Edit", new IMAGE_BRUSH( "Icons/Edit/icon_Edit_16x", Icon16x16 ) );
Set( "ContentBrowser.AssetActions.Delete", new IMAGE_BRUSH( "Icons/icon_delete_16px", Icon16x16, FLinearColor( 0.4f, 0.5f, 0.7f, 1.0f ) ) );
//Set( "ContentBrowser.AssetActions.Delete", new IMAGE_BRUSH( "Icons/Edit/icon_Edit_Delete_16x", Icon16x16) );
Set( "ContentBrowser.AssetActions.Rename", new IMAGE_BRUSH( "Icons/Icon_Asset_Rename_16x", Icon16x16) );
Set( "ContentBrowser.AssetActions.Duplicate", new IMAGE_BRUSH( "Icons/Edit/icon_Edit_Duplicate_16x", Icon16x16) );
Set( "ContentBrowser.AssetActions.OpenSourceLocation", new IMAGE_BRUSH( "Icons/icon_Asset_Open_Source_Location_16x", Icon16x16) );
Set( "ContentBrowser.AssetActions.OpenInExternalEditor", new IMAGE_BRUSH( "Icons/icon_Asset_Open_In_External_Editor_16x", Icon16x16) );
Set( "ContentBrowser.AssetActions.ReimportAsset", new IMAGE_BRUSH( "Icons/icon_TextureEd_Reimport_40x", Icon16x16 ) );
Set( "ContentBrowser.AssetActions.GoToCodeForAsset", new IMAGE_BRUSH( "GameProjectDialog/feature_code_32x", Icon16x16 ) );
Set( "ContentBrowser.AssetActions.FindAssetInWorld", new IMAGE_BRUSH( "/Icons/icon_Genericfinder_16x", Icon16x16 ) );
Set( "ContentBrowser.AssetActions.CreateThumbnail", new IMAGE_BRUSH( "Icons/icon_Asset_Create_Thumbnail_16x", Icon16x16) );
Set( "ContentBrowser.AssetActions.DeleteThumbnail", new IMAGE_BRUSH( "Icons/icon_Asset_Delete_Thumbnail_16x", Icon16x16) );
Set( "ContentBrowser.AssetActions.GenericFind", new IMAGE_BRUSH( "Icons/icon_Genericfinder_16x", Icon16x16) );

这样引擎就能通过一个名字找到对应的图片了，这些图片位于Engine\Content\Editor\Slate目录下。

创建项目设置中的选项

在Editor的模块中添加Settings的模块依赖，在模块启动时加入以下代码：

1
2
3
4
5
6
7
if (ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings"))
{
  SettingsModule->RegisterSettings("Project", "Plugins", "Hot Patcher",
            LOCTEXT("HotPatcherSettingsName", "Hot Patcher"),
            LOCTEXT("HotPatcherSettingsDescroption", "Configure the HotPatcher plugin"),
            GetMutableDefault<UHotPatcherSettings>());
}

UPL读取ini

如有以下ini配置：

1
2
3
[/Script/AndroidRuntimeSettings.AndroidRuntimeSettings]
+PackageForOculusMobile=Quest
bSupportQuestHandsTracking=True

可以使用以下方式在UPL中使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<init>
  <setBoolFromPropertyContains result="bPackageForOculusQuest" ini="Engine" section="/Script/AndroidRuntimeSettings.AndroidRuntimeSettings" property="PackageForOculusMobile" contains="Quest"/>
  <setBoolFromProperty result="bSupportsHandsTracking" ini="Engine" section="/Script/AndroidRuntimeSettings.AndroidRuntimeSettings" property="bSupportQuestHandsTracking" default="true"/>
</init>
<!-- optional updates applied to AndroidManifest.xml -->
<androidManifestUpdates>
  <if condition="bPackageForOculusQuest">
    <true>
      <if condition="bSupportsHandsTracking">
        <true>
          <!-- Oculus Hands Support -->
          <log text="Oculus Quest Hands Tracking Permissions Added!"/>
          <addPermission android:name="oculus.permission.handtracking"/>
          <addPermission android:name="oculus.permission.HAND_TRACKING"/>
          <addFeature android:name="oculus.software.handtracking" android:required="false"/>
        </true>
      </if>
    </true>
  </if>
</androidManifestUpdates>

访问系统环境变量

获取环境变量：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <stdlib.h>
#include <string>
namespace 
{
  std::string StdString(FString UEString)
  {
    return std::string(TCHAR_TO_UTF8(*UEString));
  }

  FString FStringFromStd(std::string StdString)
  {
    return FString(UTF8_TO_TCHAR(StdString.c_str()));
  }
}

FString GetEnvironmentVariable(const FString& Name)
{
  FString Value = TEXT("");

#if PLATFORM_WINDOWS
  char* Buffer;
  size_t Size;
  if (_dupenv_s(&Buffer, &Size, StdString(Name).c_str()) == 0 && Buffer != nullptr)
  {
    Value = Buffer;
    free(Buffer);
  }
#else
  char* ValueChars = getenv(StdString(Name).c_str());

  if (ValueChars != NULL) 
  {
    Value = ValueChars;
  }
#endif

  return Value;
}

设置环境变量：

1
2
3
4
5
6
7
8
9
int32 SetEnvironmentVariable(const FString& Name, const FString& Value)
{
  FString Combined = Name + TEXT("=") + Value;
#if PLATFORM_WINDOWS
  return _putenv(StdString(Combined).c_str());
#else
  return putenv(StdString(Combined).c_str());
#endif
}

Xcode stdc++错误

在Xcode10中移除了libstdc++的支持，如果在代码中使用：

1
2
3
PublicAdditionalLibraries.AddRange(new string[] {
  "stdc++.6.0.9",
});

会有以下错误：

1
ld: library not found for -lstdc++.6.0.9

息屏控制

UE中封装了通用的接口来控制，可以使用以下函数：

1
UKismetSystemLibrary::ControlScreensaver(false);

它会调用到对应平台的F*ApplicationMisc中的同名函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// for Android
bool FAndroidApplicationMisc::ControlScreensaver(EScreenSaverAction Action)
{
#if USE_ANDROID_JNI
  extern void AndroidThunkCpp_KeepScreenOn(bool Enable);
  switch (Action)
  {
    case EScreenSaverAction::Disable:
      // Prevent display sleep.
      AndroidThunkCpp_KeepScreenOn(true);
      break;

    case EScreenSaverAction::Enable:
      // Stop preventing display sleep now that we are done.
      AndroidThunkCpp_KeepScreenOn(false);
      break;
  }
  return true;
#else
  return false;
#endif
}

// for IOS
bool FIOSPlatformApplicationMisc::ControlScreensaver(EScreenSaverAction Action)
{
  IOSAppDelegate* AppDelegate = [IOSAppDelegate GetDelegate];
  [AppDelegate EnableIdleTimer : (Action == FGenericPlatformApplicationMisc::Enable)];
  return true;
}

Android

在UE的GameActivity.java.template文件中有以下函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public void AndroidThunkJava_KeepScreenOn(boolean Enable)
{
  bKeepScreenOn = Enable;
  if (Enable)
  {
    _activity.runOnUiThread(new Runnable()
        {
            @Override
            public void run()
            {
                Log.debug("==============> [JAVA] AndroidThunkJava_KeepScreenOn(true) - Disabled screen saver");
                _activity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
            }
        });
  }
  else
  {
    _activity.runOnUiThread(new Runnable()
        {
            @Override
            public void run()
            {
                Log.debug("==============> [JAVA] AndroidThunkJava_KeepScreenOn(false) - Enabled screen saver");
                _activity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
            }
        });
  }
}

在GameActivity的OnResume函数中会调用，是否开启的值为bKeepScreenOn。

可以通过UPL、或者运行时的JNI调用来控制Android是否息屏。

1
2
3
4
5
<gameActivityOnCreateFinalAdditions>
  <insert>
      AndroidThunkJava_KeepScreenOn(true);
  </insert>
</gameActivityOnCreateFinalAdditions>

IOS

在引擎中有由下代码控制：

Runtime/ApplicationCore/Private/IOS/IOSAppDelegate.cpp
1
2
3
4
5
6
7
8
9
10
-(void)InitIdleTimerSettings
{
  float TimerDuration = 0.0F;
  GConfig->GetFloat(TEXT("/Script/IOSRuntimeSettings.IOSRuntimeSettings"), TEXT("IdleTimerEnablePeriod"), TimerDuration, GEngineIni);
    IdleTimerEnablePeriod = TimerDuration;
  self.IdleTimerEnableTimer = nil;
  bool bEnableTimer = YES;
  GConfig->GetBool(TEXT("/Script/IOSRuntimeSettings.IOSRuntimeSettings"), TEXT("bEnableIdleTimer"), bEnableTimer, GEngineIni);
  [self EnableIdleTimer : bEnableTimer];
}

可以从GEngineIni中读取两个配置：

1
2
3
[/Script/IOSRuntimeSettings.IOSRuntimeSettings]
IdleTimerEnablePeriod=0.0
bEnableIdleTimer=true

当bEnableIdleTimer=false，在游戏运行时就不会息屏。

运行时设置需要调用OC的代码：

Runtime\ApplicationCore\Private\IOS\IOSAppDelegate.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
-(void)EnableIdleTimer:(bool)bEnabled
{
  dispatch_async(dispatch_get_main_queue(),^
  {
    if (bEnabled)
    {
      // Nothing needs to be done, if the enable timer is already running.
      if (self.IdleTimerEnableTimer == nil)
      {
        self.IdleTimerEnableTimer = [NSTimer scheduledTimerWithTimeInterval:IdleTimerEnablePeriod target:self selector:@selector(DeferredEnableIdleTimer) userInfo:nil repeats:NO];
      }
    }
    else
    {
      // Ensure pending attempts to enable the idle timer are cancelled.
      if (self.IdleTimerEnableTimer != nil)
      {
        [self.IdleTimerEnableTimer invalidate];
        self.IdleTimerEnableTimer = nil;
      }

      [UIApplication sharedApplication].idleTimerDisabled = NO;
      [UIApplication sharedApplication].idleTimerDisabled = YES;
    }
  });
}

调用EnableIdleTimer传入false会关闭游戏运行时息屏。

Unreal Swarm

在UE编辑器中构建光照时，会拉起一个SwarmAgent进程在后台执行光照构建任务。
UE提供了多台机器联机构建光照的支持，通过配置SwarmCoordinator与SwarmAgent作为C/S的方式来下发构建任务，实现联机烘培的效果。官方文档：Unreal Swarm。

要求：

  1. 在局域网内需要一台设备当作调度器（Coordinator），该机器上需要具有完整的引擎，并且该机器需要开放TCP的8008/8009端口的in/out，不然无法连接。
  2. 其余的机器上不要求安装引擎，但是需要运行SwarmAgent。

SwarmAgent可以从引擎的Engine\Binaries\DotNET目录下提取以下文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
C:\build_agent\workspace\SwarmAgent>tree /a /f
C:.
    AgentInterface.dll
    SwarmAgent.DeveloperOptions.xml
    SwarmAgent.exe
    SwarmAgent.exe.config
    SwarmAgent.Options.xml
    SwarmCommonUtils.dll
    SwarmCoordinator.exe
    SwarmCoordinator.exe.config
    SwarmCoordinatorInterface.dll
    SwarmInterface.dll
    UnrealControls.dll

其中SwarmAgent.Options.xml与SwarmAgent.DeveloperOptions.xml是配置文件。

需要关注的参数：

  • CacheFolder：注意该目录需要有读写权限，因为SwarmAgent可以脱离引擎单独运行，默认的引擎目录不适合，建议设置为C:\tmp\SwarmCache。
  • AllowedRemoteAgentNames：允许远程Agent分配任务到本地的名字，如果不做分组的情况，可以用通配符*允许所有的Agent
  • CoordinatorRemotingHost：局域网中运行SwarmCoordinator机器的IP地址（注意该机器需要开放TCP 8008/8009端口）
  • AvoidLocalExecution：只允许从本地分发任务，但本地不执行任务。
  • EnableStandaloneMode：SwarmAgent的独立模式，不允许传入任务，也不向其他机器分发任务。
  • ShowDeveloperMenu：显示DeveloperSettings菜单。

在DevelopSettings中可以控制超时时间、核心数等。
当配置完之后把SwarmAgent运行在其余设备上，在Coordinator的机器上就可以看到以下连接：

展示了连接的机器数，工作状态（如果SwarmCoordinator进程关闭，重启后会自动连接Agent）。
在任意启动了Agent的机器上可以开启UE启动光照构建任务（注意一定要先单独启动被配置完成的SwarmAgent，如果使用引擎自动拉起SwarmAgent则会使用一份额外的配置文件），就能在本地SwarmAgent进程中看到以下任务分配：

在SwarmCoordinator中可以看到任务分配情况：

注意：不一定所有的任务都会被分配至其他的Agent执行，取决于任务数量、Agent的负载情况等。

当Agent处于Busy状态时，Coordinator不会给其分配任务：


其他资料：

AsyncTask

有时候会开其他的线程执行任务，但是在任务中有些逻辑必须要在GameThread执行，这就需要用AsyncTask这种方式：

Runtime\Core\Private\Async\Async.cpp
1
2
3
4
5
#include "Async/Async.h"
void AsyncTask(ENamedThreads::Type Thread, TUniqueFunction<void()> Function)
{
  TGraphTask<FAsyncGraphTask>::CreateTask().ConstructAndDispatchWhenReady(Thread, MoveTemp(Function));
}

通过AsyncTask函数可以指定在某个线程执行任务：

1
2
3
4
AsyncTask(ENamedThreads::GameThread, []()
{
  // do something in GameThread
});

ENamedThread的枚举定义：

Runtime\Core\Public\Async\TaskGraphInterfaces.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
namespace ENamedThreads
{
  enum Type : int32
  {
    UnusedAnchor = -1,
    /** The always-present, named threads are listed next **/
#if STATS
    StatsThread, 
#endif
    RHIThread,
    AudioThread,
    GameThread,
    // The render thread is sometimes the game thread and is sometimes the actual rendering thread
    ActualRenderingThread = GameThread + 1,
    // CAUTION ThreadedRenderingThread must be the last named thread, insert new named threads before it

    /** not actually a thread index. Means "Unknown Thread" or "Any Unnamed Thread" **/
    AnyThread = 0xff, 

    /** High bits are used for a queue index and priority**/

    MainQueue =     0x000,
    LocalQueue =    0x100,

    NumQueues =     2,
    ThreadIndexMask = 0xff,
    QueueIndexMask =  0x100,
    QueueIndexShift = 8,

    /** High bits are used for a queue index task priority and thread priority**/

    NormalTaskPriority =  0x000,
    HighTaskPriority =    0x200,

    NumTaskPriorities =   2,
    TaskPriorityMask =    0x200,
    TaskPriorityShift =   9,

    NormalThreadPriority = 0x000,
    HighThreadPriority = 0x400,
    BackgroundThreadPriority = 0x800,

    NumThreadPriorities = 3,
    ThreadPriorityMask = 0xC00,
    ThreadPriorityShift = 10,

    /** Combinations **/
#if STATS
    StatsThread_Local = StatsThread | LocalQueue,
#endif
    GameThread_Local = GameThread | LocalQueue,
    ActualRenderingThread_Local = ActualRenderingThread | LocalQueue,

    AnyHiPriThreadNormalTask = AnyThread | HighThreadPriority | NormalTaskPriority,
    AnyHiPriThreadHiPriTask = AnyThread | HighThreadPriority | HighTaskPriority,

    AnyNormalThreadNormalTask = AnyThread | NormalThreadPriority | NormalTaskPriority,
    AnyNormalThreadHiPriTask = AnyThread | NormalThreadPriority | HighTaskPriority,

    AnyBackgroundThreadNormalTask = AnyThread | BackgroundThreadPriority | NormalTaskPriority,
    AnyBackgroundHiPriTask = AnyThread | BackgroundThreadPriority | HighTaskPriority,
  };
  // ...
}

MSVC的警告/错误编号

MSVC成员初始化顺序不一致警告

在编译MAC/IOS时开启了Wreorder，在以下情况中会产生错误：

1
2
3
4
5
6
struct A
{
    A(int a) : y(a), x(y) {}
    int x;
    int y;
};

但是MSVC默认没有这个检测，会导致在MSVC编译的过，在Mac上编译不过的情况。

从VS2017开始，提供了一个编译器参数/w15038，可以用在Win上开启相似的警告。

在UE中使用AdditionalCompilerArguments添加即可（非Editor的TargetRules）。

1
StarterContent425.h(9): [C5038] data member 'A::y' will be initialized after data member 'A::x'

按照名字规则加载模块

如Shader编译、Texture的压缩等功能，支持很多的类型，UE里也分别实现了很多个模块，每个模块支持某种规则，这也是UE功能组织的一种方法，类似的方法UE中还有Modular Feature：ModularFeature：为UE4集成ZSTD压缩算法。

Source/Developer/TargetPlatform/Private/TargetPlatformManagerModule.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
virtual const TArray<const IShaderFormat*>& GetShaderFormats() override
{
  static bool bInitialized = false;
  static TArray<const IShaderFormat*> Results;

  if (!bInitialized || bForceCacheUpdate)
  {
    bInitialized = true;
    Results.Empty(Results.Num());

    TArray<FName> Modules;

    FModuleManager::Get().FindModules(SHADERFORMAT_MODULE_WILDCARD, Modules);

    if (!Modules.Num())
    {
      UE_LOG(LogTargetPlatformManager, Error, TEXT("No target shader formats found!"));
    }

    for (int32 Index = 0; Index < Modules.Num(); Index++)
    {
      IShaderFormatModule* Module = FModuleManager::LoadModulePtr<IShaderFormatModule>(Modules[Index]);
      if (Module)
      {
        IShaderFormat* Format = Module->GetShaderFormat();
        if (Format != nullptr)
        {
          Results.Add(Format);
        }
      }
    }
  }
  return Results;
}

需要注意的是FMouduleManager::Get().FindModules这个，第一个参数支持规则：

1
2
#define SHADERFORMAT_MODULE_WILDCARD TEXT("*ShaderFormat*")
FModuleManager::Get().FindModules(SHADERFORMAT_MODULE_WILDCARD, Modules);

这样就会把所有匹配这个名字规则的Module得到，然后再按照统一的接口来维护

性能优化：设备分级

为高性能和较低性能的设备进行差异化的配置策略。

打印调用栈

使用FDebug中的函数：

1
FDebug::DumpStackTraceToLog();

会有以下输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
LogStats: FPlatformStackWalk::StackWalkAndDump -  0.012 s
LogOutputDevice: Error: begin: stack for UAT
LogOutputDevice: Error: === FDebug::DumpStackTrace(): ===
LogOutputDevice: Error: 
LogOutputDevice: Error: [Callstack] 0x00007ffce24a94f6 UE4Editor-DerivedDataCache.dll!FDerivedDataCache::GetSynchronous() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Developer\DerivedDataCache\Private\DerivedDataCache.cpp:328]
LogOutputDevice: Error: [Callstack] 0x00007ffcdec9218b UE4Editor-NavigationSystem.dll!UNavCollision::GetCookedData() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\NavigationSystem\Private\NavCollision.cpp:553]
LogOutputDevice: Error: [Callstack] 0x00007ffcdecc5662 UE4Editor-NavigationSystem.dll!UNavCollision::Setup() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\NavigationSystem\Private\NavCollision.cpp:219]
LogOutputDevice: Error: [Callstack] 0x00007ffce9e21b56 UE4Editor-Engine.dll!UStaticMesh::PostLoad() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\Engine\Private\StaticMesh.cpp:5100]
LogOutputDevice: Error: [Callstack] 0x00007ffcef299ae2 UE4Editor-CoreUObject.dll!UObject::ConditionalPostLoad() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\CoreUObject\Private\UObject\Obj.cpp:1067]
LogOutputDevice: Error: [Callstack] 0x00007ffce8de7432 UE4Editor-Engine.dll!UBodySetup::PostLoad() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\Engine\Private\PhysicsEngine\BodySetup.cpp:1079]
LogOutputDevice: Error: [Callstack] 0x00007ffcef299ae2 UE4Editor-CoreUObject.dll!UObject::ConditionalPostLoad() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\CoreUObject\Private\UObject\Obj.cpp:1067]
LogOutputDevice: Error: [Callstack] 0x00007ffcef36147c UE4Editor-CoreUObject.dll!EndLoad() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\CoreUObject\Private\UObject\UObjectGlobals.cpp:1592]
LogOutputDevice: Error: [Callstack] 0x00007ffcef34b8b7 UE4Editor-CoreUObject.dll!<lambda_84bbae4d81099727504625d58dce15aa>::operator()() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\CoreUObject\Private\UObject\UObjectGlobals.cpp:1231]
LogOutputDevice: Error: [Callstack] 0x00007ffcef370b4b UE4Editor-CoreUObject.dll!LoadPackageInternal() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\CoreUObject\Private\UObject\UObjectGlobals.cpp:1332]
LogOutputDevice: Error: [Callstack] 0x00007ffcef36fad0 UE4Editor-CoreUObject.dll!LoadPackage() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\CoreUObject\Private\UObject\UObjectGlobals.cpp:1427]
LogOutputDevice: Error: [Callstack] 0x00007ffcef384aff UE4Editor-CoreUObject.dll!ResolveName() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\CoreUObject\Private\UObject\UObjectGlobals.cpp:767]
LogOutputDevice: Error: [Callstack] 0x00007ffcef3975d5 UE4Editor-CoreUObject.dll!StaticLoadObjectInternal() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\CoreUObject\Private\UObject\UObjectGlobals.cpp:829]
LogOutputDevice: Error: [Callstack] 0x00007ffcef396ca3 UE4Editor-CoreUObject.dll!StaticLoadObject() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\CoreUObject\Private\UObject\UObjectGlobals.cpp:904]
LogOutputDevice: Error: [Callstack] 0x00007ffd02b83b11 UE4Editor-CinematicCamera.dll!ConstructorHelpersInternal::FindOrLoadObject<UStaticMesh>() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\CoreUObject\Public\UObject\ConstructorHelpers.h:36]
LogOutputDevice: Error: [Callstack] 0x00007ffd02b861ac UE4Editor-CinematicCamera.dll!ACameraRig_Crane::ACameraRig_Crane() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\CinematicCamera\Private\CameraRig_Crane.cpp:45]
LogOutputDevice: Error: [Callstack] 0x00007ffcef0f6cc3 UE4Editor-CoreUObject.dll!UClass::CreateDefaultObject() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\CoreUObject\Private\UObject\Class.cpp:3672]
LogOutputDevice: Error: [Callstack] 0x00007ffcef39baf1 UE4Editor-CoreUObject.dll!UObjectLoadAllCompiledInDefaultProperties() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\CoreUObject\Private\UObject\UObjectBase.cpp:861]
LogOutputDevice: Error: [Callstack] 0x00007ffcef37920f UE4Editor-CoreUObject.dll!ProcessNewlyLoadedUObjects() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\CoreUObject\Private\UObject\UObjectBase.cpp:950]
LogOutputDevice: Error: [Callstack] 0x00007ff6fc231ce1 UE4Editor-Cmd.exe!FEngineLoop::PreInitPostStartupScreen() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\Launch\Private\LaunchEngineLoop.cpp:3039]
LogOutputDevice: Error: [Callstack] 0x00007ff6fc22b7ad UE4Editor-Cmd.exe!GuardedMain() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\Launch\Private\Launch.cpp:127]
LogOutputDevice: Error: [Callstack] 0x00007ff6fc22bb0a UE4Editor-Cmd.exe!GuardedMainWrapper() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\Launch\Private\Windows\LaunchWindows.cpp:137]
LogOutputDevice: Error: [Callstack] 0x00007ff6fc23e2dd UE4Editor-Cmd.exe!WinMain() [C:\build_agent\workspace\FGameEngine\Engine\Engine\Source\Runtime\Launch\Private\Windows\LaunchWindows.cpp:268]
LogOutputDevice: Error: [Callstack] 0x00007ff6fc2403be UE4Editor-Cmd.exe!__scrt_common_main_seh() [d:\A01\_work\6\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:288]
LogOutputDevice: Error: [Callstack] 0x00007ffd5c217c24 KERNEL32.DLL!UnknownFunction []
LogOutputDevice: Error: [Callstack] 0x00007ffd5ce4d4d1 ntdll.dll!UnknownFunction []
LogOutputDevice: Error: 
LogOutputDevice: Error: end: stack for UAT

Windows Metal Shader Compiler for IOS

在4.26及更高的引擎版本中，支持在Windows上直接安装Metal Sahder Compiler来支持在Windows上编译Metal的Shader，只需要在Apple开发者网站上安装Metal Developer Tools for Windows工具安装即可。OneDrive分流：Metal_Developer_Tools1.2Windows.exe。

4.26引擎执行Cook时的Log，可以看到创建了Metallib：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
Running: C:\Program Files\Epic Games\UE_4.26\Engine\Binaries\Win64\UE4Editor-Cmd.exe "C:\Users\lipengzha\Documents\Unreal Projects\StarterContent426\StarterContent426.uproject" -run=Cook  -TargetPlatform=IOS -fileopenlog -ddc=InstalledDerivedDataBackendGraph -unversioned -abslog="C:\Program Files\Epic Games\UE_4.26\Engine\Programs
\AutomationTool\Saved\Cook-2021.04.08-10.06.40.txt" -stdout -CrashForUAT -unattended -NoLogTimes  -UTF8Output
  LogInit: Display: Running engine for game: StarterContent426
  LogHAL: Display: Platform has ~ 32 GB [34123063296 / 34359738368 / 32], which maps to Largest [LargestMinGB=32, LargerMinGB=12, DefaultMinGB=8, SmallerMinGB=6, SmallestMinGB=0)
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'AllDesktop'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'Android'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'Android_ASTC'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'Android_DXT'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'Android_ETC2'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'AndroidClient'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'Android_ASTCClient'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'Android_DXTClient'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'Android_ETC2Client'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'Android_Multi'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'Android_MultiClient'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'IOSClient'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'IOS'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'Linux'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'LinuxNoEditor'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'LinuxClient'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'LinuxServer'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'LinuxAArch64NoEditor'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'LinuxAArch64Client'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'LinuxAArch64Server'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'Lumin'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'LuminClient'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'MacNoEditor'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'Mac'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'MacClient'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'MacServer'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'TVOSClient'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'TVOS'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'WindowsNoEditor'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'Windows'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'WindowsClient'
  LogTargetPlatformManager: Display: Loaded TargetPlatform 'WindowsServer'
  LogTargetPlatformManager: Display: Building Assets For IOS
  LogAudioDebug: Display: Lib vorbis DLL was dynamically loaded.
  LogShaderCompilers: Display: Using Local Shader Compiler.
  LogDerivedDataCache: Display: Max Cache Size: 512 MB
  LogDerivedDataCache: Display: Loaded Boot cache: C:/Users/lipengzha/AppData/Local/UnrealEngine/4.26/DerivedDataCache/Boot.ddc
  LogDerivedDataCache: Display: Pak cache opened for reading ../../../Engine/DerivedDataCache/Compressed.ddp.
  LogDerivedDataCache: Display: Performance to C:/Users/lipengzha/AppData/Local/UnrealEngine/Common/DerivedDataCache: Latency=0.06ms. RandomReadSpeed=291.68MBs, RandomWriteSpeed=137.99MBs. Assigned SpeedClass 'Local'
  LogMaterial: Display: Missing cached shader map for material Widget3DPassThrough, compiling.
  LogMaterial: Display: Missing cached shader map for material Widget3DPassThrough, compiling.
  LogMaterial: Display: Missing cached shader map for material Widget3DPassThrough, compiling.
  LogMaterial: Display: Missing cached shader map for material Widget3DPassThrough, compiling.
  LogMaterial: Display: Missing cached shader map for material Widget3DPassThrough, compiling.
  LogMaterial: Display: Missing cached shader map for material Widget3DPassThrough, compiling.
  LogMaterial: Display: Missing cached shader map for material DefaultSpriteMaterial, compiling.
  LogAudioCaptureCore: Display: No Audio Capture implementations found. Audio input will be silent.
  LogAudioCaptureCore: Display: No Audio Capture implementations found. Audio input will be silent.
  LogCook: Display: CookSettings for Memory: MemoryMaxUsedVirtual 0MiB, MemoryMaxUsedPhysical 16384MiB, MemoryMinFreeVirtual 0MiB, MemoryMinFreePhysical 1024MiB
  LogCook: Display: Mobile HDR setting 1
  LogCook: Display: Creating asset registry
  LogCook: Display: Discovering localized assets for cultures: en
  LogCook: Display: Unable to read previous cook inisettings for platform IOS invalidating cook
  LogCook: Display: Clearing all cooked content for platform IOS
  LogCook: Display: Sandbox cleanup took 0.025 seconds for platforms IOS
  LogMetalShaderCompiler: Display: Creating Native Library C:/Users/lipengzha/Documents/Unreal Projects/StarterContent426/Saved/Cooked/IOS/StarterContent426/Content/Global_SF_METAL.0.metallib
  LogMetalShaderCompiler: Display: Archiving 685 shaders for shader platform: SF_METAL
  LogZipArchiveWriter: Display: Closing zip file with 0 entries.
  LogMetalShaderCompiler: Display: Post-processing archive for shader platform: SF_METAL
  LogCook: Display: Cooked packages 0 Packages Remain 314 Total 314

打包出来的Shadercode不是ushaderbytecode文件，而是和Mac上打包一致的metallib。

Loaded a text shader (will be slower to load)

当使用远程构建的方式打包了IOS包，在运行时会有以下log：

1
LogMetal: Display: Loaded a text shader (will be slower to load)

该日志在以下代码中输出：

Source\Runtime\Apple\MetalRHI\Private\MetalShaders.cpp
1
2
3
4
5
6
/** Initialization constructor. */
template<typename BaseResourceType, int32 ShaderType>
void TMetalBaseShader<BaseResourceType, ShaderType>::Init(TArrayView<const uint8> InShaderCode, FMetalCodeHeader& Header, mtlpp::Library InLibrary)
{
  // ...
}

这是因为加载的Shader需要实时编译，会比较慢，可以在项目设置中为IOS开启remote shader compile，在UE4.26之后，也可以通过本地安装metal的工具链在本地编译metal的shader。

rust in unreal

uhtmanifest

在以下路径里有个xxxx.uhtmanifest文件:

1
2
Intermediate/Build/PLATFORM/TARGETNAME/CONFIGURATION/*.uhtmanifest
Intermediate/Build/Win64/UE4Game/Development/UE4Game.uhtmanifest

里面记录了编译的Module和类型等信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
{
   "IsGameTarget":true,
   "RootLocalPath":"C:\\build_agent\\workspace\\FGameEngine\\Engine",
   "TargetName":"UE4Game",
   "ExternalDependenciesFile":"C:\\build_agent\\workspace\\FGameEngine\\Engine\\Engine\\Intermediate\\Build\\Win64\\UE4Game\\Development\\UE4Game.deps",
   "Modules":[
      {
         "Name":"CoreUObject",
         "ModuleType":"EngineRuntime",
         "BaseDirectory":"C:\\build_agent\\workspace\\FGameEngine\\Engine\\Engine\\Source\\Runtime\\CoreUObject",
         "IncludeBase":"C:\\build_agent\\workspace\\FGameEngine\\Engine\\Engine\\Source\\Runtime",
         "OutputDirectory":"C:\\build_agent\\workspace\\FGameEngine\\Engine\\Engine\\Intermediate\\Build\\Win64\\UE4\\Inc\\CoreUObject",
         "ClassesHeaders":[
            
         ],
         "PublicHeaders":[
            "C:\\build_agent\\workspace\\FGameEngine\\Engine\\Engine\\Source\\Runtime\\CoreUObject\\Public\\UObject\\CoreNetTypes.h",
            "C:\\build_agent\\workspace\\FGameEngine\\Engine\\Engine\\Source\\Runtime\\CoreUObject\\Public\\UObject\\CoreOnline.h",
            "C:\\build_agent\\workspace\\FGameEngine\\Engine\\Engine\\Source\\Runtime\\CoreUObject\\Public\\UObject\\NoExportTypes.h"
         ],
         "PrivateHeaders":[
            
         ],
         "GeneratedCPPFilenameBase":"C:\\build_agent\\workspace\\FGameEngine\\Engine\\Engine\\Intermediate\\Build\\Win64\\UE4\\Inc\\CoreUObject\\CoreUObject.gen",
         "SaveExportedHeaders":true,
         "UHTGeneratedCodeVersion":"None"
      }
  ]
}

附录一份引擎中编译UE4Game的uhtmanifest：UE4Game.uhtmanifest，可以对引擎中的Module进行分析，如果有些模块不需要，可以进行裁剪。

震动反馈

Incredibuild对FASTBuild的影响

在安装Visual Studio时勾选了安装Incredibuild，如果系统中同时安装了FASTBuild等工具（如NEXTBuild），在使用BuildGraph执行编译时会优先使用Incredibuild，起不到加速的效果。
解决办法就是在Visual Studio Installer中卸载掉Incredibuild。

交叉编译工具链

在编译Linux用的DS时需要用到交叉编译工具链：

安装之后把安装目录添加至LINUX_MULTIARCH_ROOT环境变量，可以通过以下命令检测是否安装成功：

1
%LINUX_MULTIARCH_ROOT%x86_64-unknown-linux-gnu\bin\clang++ -v

安装工具链之后重新生成工程，可以通过RunUAT来进行交叉编译DS：

1
2
3
4
5
6
7
8
# REM 【ProjectName】, 【ProjectNameServer】需要修改为项目对应的名称，【ArchiveDirectory】修改为输出目录：
Engine\Build\BatchFiles\RunUAT.bat BuildCookRun -nocompileeditor -nop4
 -project=【ProjectName】.uproject
 -cook -stage -archive -archivedirectory=【ArchiveDirectory】
 -package -ue4exe="Engine\Binaries\Win64\UE4Editor-Cmd.exe"  -ddc=DerivedDataBackendGraph -pak -prereqs
 -nodebuginfo -server -noclient -targetplatform=Linux -serverplatform=Linux -build -skipbuildclient
 -target=【ProjectNameServer】
 -clientconfig=Development -serverconfig=Development -utf8output -compile

IOS签名错误排查

No certificate for team xxxx matching

如果有以下错误提示：

1
Code Signing Error: No certificate for team '9TV4ZYSS4J' matching 'iPhone Developer: Created via API (JDPXHYVWYZ)' found: Select a different signing certificate for CODE_SIGN_IDENTITY, a team that matches your selected certificate, or switch to autom atic provisioning.

解决办法：

  1. 在Mac上的~/Library/MobileDevice/Provisioning\ Profiles清理掉多余的mobileprovision文件。
  2. 在Mac钥匙串中清理掉过期的开发者证书
  3. 重新导入mobileprovision与证书

注意：导入的mobileprovision的文件命名要与在BaseEngine.ini中指定的MobileProvision相同。

errSecInternalComponent错误

是因为通过ssh去调用/usr/bin/codesign访问钥匙串没有权限，可以使用以下命令在ssh中执行解锁：

1
security unlock-keychain -p password login.keychain

在UE远程构建时，可以先执行这条命令在当前的ssh环境下解锁keychain，使后面的签名可以正常执行。
修改UE中的Engine\Build\BatchFiles\Mac\Build.sh文件，在调用UBT编译之前，写入以下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#!/bin/sh

cd "`dirname "$0"`/../../../.."

# Setup Mono
source Engine/Build/BatchFiles/Mac/SetupMono.sh Engine/Build/BatchFiles/Mac

if [ "$4" == "-buildscw" ] || [ "$5" == "-buildscw" ]; then
  echo Building ShaderCompileWorker...
  mono Engine/Binaries/DotNET/UnrealBuildTool.exe ShaderCompileWorker Mac Development
fi
echo unlock mac keychain...
security unlock-keychain -p password login.keychain
echo Running command : Engine/Binaries/DotNET/UnrealBuildTool.exe "$@"
mono Engine/Binaries/DotNET/UnrealBuildTool.exe "$@"

ExitCode=$?
if [ $ExitCode -eq 254 ] || [ $ExitCode -eq 255 ] || [ $ExitCode -eq 2 ]; then
  exit 0
else
  exit $ExitCode
fi

因为编译时会把Build.sh通过RSync传递到Mac上，所以可以看到以下log:

1
2
3
4
5
6
7
8
9
10
11
[Remote] Executing build
  Running bundled mono, version: Mono JIT compiler version 5.16.0.220 (2018-06/bb3ae37d71a Fri Nov 16 17:12:11 EST 2018)
  unlock mac keychain...
  Running command : Engine/Binaries/DotNET/UnrealBuildTool.exe UnrealHeaderTool Mac Development -SkipRulesCompile -XmlConfigCache=/Users/buildmachine/UE4/Builds/lipengzha-PC2/C/BuildAgent/workspace/FGameEngine/Engine/Engine/Intermediate/Build/XmlConfigCache.bin -precompile -allmodules -Log=/Users/buildmachine/UE4/Builds/lipengzha-PC2/C/BuildAgent/workspace/FGameEngine/Engine/Engine/Programs/AutomationTool/Saved/Logs/UBT-UnrealHeaderTool-Mac-Development_Remote.txt -Manifest=/Users/buildmachine/UE4/Builds/lipengzha-PC2/C/BuildAgent/workspace/FGameEngine/Engine/Engine/Intermediate/Remote/UnrealHeaderTool/Mac/Development/Manifest.xml
  Target is up to date
  Deploying UnrealHeaderTool Mac Development...
  Deploying now!
  Total execution time: 1.01 seconds
[Remote] Downloading C:\BuildAgent\workspace\FGameEngine\Engine\Engine\Intermediate\Remote\UnrealHeaderTool\Mac\Development\Manifest.xml
[Remote] Downloading build products
  receiving file list ... done

这样每次编译都会解锁keychain，从而避免ssh连接时没有访问codesign导致的签名错误。

注意：也需要排查BaseEngine.ini中SigningCertificate的值是否被指定。

Invalid trust settings.

如果Log中出现以下错误：

1
2
Code Signing Error: Invalid trust settings. Restore system default trust settings for certificate "iPhone Developer: Created via API (JDPXHYVWYZ)" in order to sign code with it.
Code Signing Error: Code signing is required for product type 'Application' in SDK 'iOS 13.6'

这是因为在Mac上的钥匙串中对证书的设置被修改为了始终信任，修改回使用系统默认即可。

IOS MobileProvision路径

位于以下路径，可以清理掉过期或者多余的mobileprovision：

1
~/Library/MobileDevice/Provisioning\ Profiles

漏掉PRAGMA_ENABLE_OPTIMIZATION导致的编译错误

有时候希望关闭代码优化，在UE中可以使用封装的宏：

1
2
3
PRAGMA_DISABLE_OPTIMIZATION
// ...
PRAGMA_ENABLE_OPTIMIZATION

但是如果漏掉了PRAGMA_ENABLE_OPTIMIZATION，有时会产生以下编译错误（尤其是包含了Slate等模块的代码）：

1
2
3
2>D:\Client\Plugins\UMGExtention\Intermediate\Build\Win64\UE4Editor\Development\UMGExtention\Module.UMGExtention.cpp(16): Error C4426 : optimization flags changed after including header, may be due to #pragma optimize()
2>D:\Client\Plugins\UMGExtention\Intermediate\Build\Win64\UE4Editor\Development\UMGExtention\Module.UMGExtention.cpp(24): Error C4426 : optimization flags changed after including header, may be due to #pragma optimize()
2>EXEC: Error  : 2 (0x02) Target: 'D:\Client\Plugins\UMGExtention\Intermediate\Build\Win64\UE4Editor\Development\UMGExtention\Module.UMGExtention.cpp.obj'

读取文件的一部分

可以使用IFileHandle来实现，它有seek函数可以随意偏移。

Runtime\Core\Public\GenericPlatform\GenericPlatformFile.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/** 
 * File handle interface. 
**/
class CORE_API IFileHandle
{
public:
  /** Destructor, also the only way to close the file handle **/
  virtual ~IFileHandle()
  {
  }

  /** Return the current write or read position. **/
  virtual int64   Tell() = 0;
  /** 
   * Change the current write or read position. 
   * @param NewPosition new write or read position
   * @return        true if the operation completed successfully.
  **/
  virtual bool    Seek(int64 NewPosition) = 0;

  /** 
   * Change the current write or read position, relative to the end of the file.
   * @param NewPositionRelativeToEnd  new write or read position, relative to the end of the file should be <=0!
   * @return              true if the operation completed successfully.
  **/
  virtual bool    SeekFromEnd(int64 NewPositionRelativeToEnd = 0) = 0;

  /** 
   * Read bytes from the file.
   * @param Destination Buffer to holds the results, should be at least BytesToRead in size.
   * @param BytesToRead Number of bytes to read into the destination.
   * @return        true if the operation completed successfully.
  **/
  virtual bool    Read(uint8* Destination, int64 BytesToRead) = 0;

  /** 
   * Write bytes to the file.
   * @param Source    Buffer to write, should be at least BytesToWrite in size.
   * @param BytesToWrite  Number of bytes to write.
   * @return        true if the operation completed successfully.
  **/
  virtual bool    Write(const uint8* Source, int64 BytesToWrite) = 0;

  /**
   * Flushes file handle to disk.
   * @param bFullFlush  true to flush everything about the file (including its meta-data) with a strong guarantee that it will be on disk by the time this function returns, 
   *            or false to let the operating/file system have more leeway about when the data actually gets written to disk
   * @return        true if operation completed successfully.
  **/
  virtual bool    Flush(const bool bFullFlush = false) = 0;

  /** 
   * Truncate the file to the given size (in bytes).
   * @param NewSize   Truncated file size (in bytes).
   * @return        true if the operation completed successfully.
  **/
  virtual bool    Truncate(int64 NewSize) = 0;

public:
  /////////// Utility Functions. These have a default implementation that uses the pure virtual operations.

  /** Return the total size of the file **/
  virtual int64   Size();
};

创建它的方法首先需要拿到PlatformFile:

1
IPlatformFile& PlatformFile = FPlatformFileManager::Get().GetPlatformFile();

然后通过它的OpenRead/OpenWrite方法来创建一个IFileHandle：

Runtime\Core\Public\GenericPlatform\GenericPlatformFile.h
1
2
3
4
5
6
7
8
9
10
11
/** Attempt to open a file for reading.
 *
 * @param Filename file to be opened
 * @param bAllowWrite (applies to certain platforms only) whether this file is allowed to be written to by other processes. This flag is needed to open files that are currently being written to as well.
 *
 * @return If successful will return a non-nullptr pointer. Close the file by delete'ing the handle.
 */
virtual IFileHandle* OpenRead(const TCHAR* Filename, bool bAllowWrite = false) = 0;

/** Attempt to open a file for writing. If successful will return a non-nullptr pointer. Close the file by delete'ing the handle. **/
virtual IFileHandle* OpenWrite(const TCHAR* Filename, bool bAppend = false, bool bAllowRead = false) = 0;

PlatformFile具有跨平台实现，在不同的平台拿到的类型是不一样的，如FIOSPlatformFile/FAndroidPlatformFile等等，具有相同接口的实现。

UE从Pak中加载文件就是通过这样的方式来实现的。

PakBlackList

可以在{PROJECT_DIR}/Build/{PLATFORM}下创建PakBlackList-{CONFIGURATION}.txt文件来限制打包项目时生成的PakList*.txt中的内容：

1
2
3
4
{PROJECTDIR}/Build/Android/PakBlacklist-Shipping.txt
{PROJECTDIR}/Build/Android/PakBlacklist-Debug.txt
{PROJECTDIR}/Build/Android/PakBlacklist-Development.txt
{PROJECTDIR}/Build/Android/PakBlacklist-Test.txt

等文件，按照PakBlackList-{CONFIGURATION}.txt的规则命名，打不同Configuration的包就会去读取对应的文件。

文件中需要填写MountPoint的路径：

1
../../../Client/BlackDir

当打包时生成Paklist时会判断是否匹配这里的规则（StartWith），从而控制是否包含。

相关的代码在Programs/AutomationTool/Script/CopyBuildToStagingDirectory.Automation.cs：

Programs/AutomationTool/Script/CopyBuildToStagingDirectory.Automation.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
/// <summary>
/// Creates a pak response file using stage context
/// </summary>
/// <param name="SC"></param>
/// <returns></returns>
private static Dictionary<string, string> CreatePakResponseFileFromStagingManifest(DeploymentContext SC, Dictionary<StagedFileReference, FileReference> FilesToStage)
{
  // look for optional packaging blacklist if only one config active
  List<string> Blacklist = null;
  if (SC.StageTargetConfigurations.Count == 1) 
  {
    FileReference PakBlacklistFilename = FileReference.Combine(SC.ProjectRoot, "Build", SC.PlatformDir, string.Format("PakBlacklist-{0}.txt", SC.StageTargetConfigurations[0].ToString()));
    if (FileReference.Exists(PakBlacklistFilename)) 
    {
      LogInformation("Applying PAK blacklist file {0}. This is deprecated in favor of DefaultPakFileRules.ini", PakBlacklistFilename);
      string[] BlacklistContents = FileReference.ReadAllLines(PakBlacklistFilename);
      foreach (string Candidate in BlacklistContents) 
      {
        if (Candidate.Trim().Length > 0) 
        {
          if (Blacklist == null) 
          {
            Blacklist = new List<string>();
          }
          Blacklist.Add(Candidate);
        }
      }
    }
  }

  var UnrealPakResponseFile = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
  foreach (KeyValuePair<StagedFileReference, FileReference> Pair in FilesToStage) 
  {
    FileReference Src = Pair.Value;
    string Dest = Pair.Key.Name;

    Dest = CombinePaths(PathSeparator.Slash, SC.PakFileInternalRoot, Dest);

    if (Blacklist != null) 
    {
      bool bExcludeFile = false;
      foreach (string ExcludePath in Blacklist) 
      {
        if (Dest.StartsWith(ExcludePath)) 
        {
          bExcludeFile = true;
          break;
        }
      }

      if (bExcludeFile) {
        LogInformation("Excluding {0}", Src);
        continue;
      }
    }

    // Filter I/O store container files
    if (Src.HasExtension(".ucas") || Src.HasExtension(".utoc"))
    {
      LogInformation("Excluding {0}", Src);
      continue;
    }

    // Do a filtered copy of all ini files to allow stripping of values that we don't want to distribute
    if (Src.HasExtension(".ini")) 
    {
      string SubFolder = Pair.Key.Name.Replace('/', Path.DirectorySeparatorChar);
      FileReference NewIniFilename = FileReference.Combine(SC.ProjectRoot, "Saved", "Temp", SC.PlatformDir, SubFolder);
      InternalUtils.SafeCreateDirectory(NewIniFilename.Directory.FullName, true);
      InternalUtils.SafeCopyFile(Src.FullName, NewIniFilename.FullName, IniKeyBlacklist
                     : SC.IniKeyBlacklist, IniSectionBlacklist
                     : SC.IniSectionBlacklist);
      Src = NewIniFilename;
    }

    // there can be files that only differ in case only, we don't support that in paks as paks are case-insensitive
    if (UnrealPakResponseFile.ContainsKey(Src.FullName)) 
    {
      if (UnrealPakResponseFile[Src.FullName] != Dest) 
      {
        throw new AutomationException("Staging manifest already contains {0} (or a file that differs in case only)", Src);
      }
      LogWarning("Tried to add duplicate file to stage " + Src + " ignoring second attempt pls fix");
      continue;
    }

    UnrealPakResponseFile.Add(Src.FullName, Dest);
  }

  return UnrealPakResponseFile;
}

[/Script/BuildSettings.BuildSettings]

可以在Engine.ini中控制以下参数，选择性的编译某些功能，这些参数在TargetRules中定义：Programs/UnrealBuildTool/Configuration/TargetRules.cs

它们都是TargetRules的成员，可以直接在Target.cs中设置值，部分参数也可以在ini中配置，可配置的ini如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[/Script/BuildSettings.BuildSettings]
;Whether to include PhysX APEX support.
bCompileAPEX=true
;Whether to include ICU unicode/i18n support in Core.
bCompileICU=true
;Whether to compile CEF3 support.
bCompileCEF3=true
;Whether we should compile SQLite using the custom "Unreal" platform (true), or using the native platform (false).
bCompileCustomSQLitePlatform=true
;Whether to utilize cache freed OS allocs with MallocBinned
bUseCacheFreedOSAllocs=true
;Whether to compile Recast navmesh generation.
bCompileRecast=true
;Whether to compile SpeedTree support.
bOverrideCompileSpeedTree=true
;Whether to include plugin support.
bCompileWithPluginSupport=false
;Whether to include PerfCounters support.
bWithPerfCountersOverride=true
;True if we need FreeType support.
bCompileFreeType=true
;True if we want to favor optimizing size over speed.
bCompileForSize=true

选择性地去关闭这些可以减少so的大小5-10M。

Unreal Insights的初始化

开启Unreal Insights的采集可以使用命令行参数：-trace=counters,cpu,frame,bookmark,gpu，在引擎启动时会解析要采集的模块：

Runtime\Launch\Private\LaunchEngineLoop.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
int32 FEngineLoop::PreInitPreStartupScreen(const TCHAR* CmdLine)
{
  FDelayedAutoRegisterHelper::RunAndClearDelayedAutoRegisterDelegates(EDelayedRegisterRunPhase::StartOfEnginePreInit);

#if UE_TRACE_ENABLED
  {
    Trace::Initialize();

    FString EnabledChannels;
    FParse::Value(CmdLine, TEXT("-trace="), EnabledChannels, false);
    UE::String::ParseTokens(EnabledChannels, TEXT(","), [](FStringView Token) {
      TCHAR ChannelName[64];
      const size_t ChannelNameSize = Token.CopyString(ChannelName, 64);
      ChannelName[ChannelNameSize] = '\0';
      Trace::ToggleChannel(ChannelName, true);
    });

    TRACE_REGISTER_GAME_THREAD(FPlatformTLS::GetCurrentThreadId());
    TRACE_CPUPROFILER_INIT(CmdLine);
    TRACE_PLATFORMFILE_INIT(CmdLine);
    TRACE_COUNTERS_INIT(CmdLine);
  }
#endif

  SCOPED_BOOT_TIMING("FEngineLoop::PreInitPreStartupScreen");
  
  // ...
}

UPackage::Save

Package的存储过程是放到一个单独的线程去执行的:

Runtime\CoreUObject\Private\UObject\SavePackage.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
static void AsyncWriteFileWithSplitExports(TAsyncWorkSequence<FMD5>& AsyncWriteAndHashSequence, FLargeMemoryPtr Data, const int64 DataSize, const int64 HeaderSize, const TCHAR* Filename, EAsyncWriteOptions Options)
{
  OutstandingAsyncWrites.Increment();
  FString OutputFilename(Filename);
  AsyncWriteAndHashSequence.AddWork([Data = MoveTemp(Data), DataSize, HeaderSize, OutputFilename = MoveTemp(OutputFilename), Options](FMD5& State) mutable
  {
    if (EnumHasAnyFlags(Options, EAsyncWriteOptions::ComputeHash))
    {
      State.Update(Data.Get(), DataSize);
    }

    if (EnumHasAnyFlags(Options, EAsyncWriteOptions::WriteFileToDisk))
    {
      // Write .uasset file
      WriteToFile(OutputFilename, Data.Get(), HeaderSize);

      // Write .uexp file
      const FString FilenameExports = FPaths::ChangeExtension(OutputFilename, TEXT(".uexp"));
      WriteToFile(FilenameExports, Data.Get() + HeaderSize, DataSize - HeaderSize);
    }

    OutstandingAsyncWrites.Decrement();
  });
}

调用栈为：

在通过UPackage::Save来执行Cook资源的存储并立即打包的操作可能会导致在该Task线程中还没有存储完毕，其他线程就已经开始打包了，导致打包包含文件失败。

UE内置的Release Patch

UE的Patch有一些缺点：

  • 无法精确地控制Patch包含的内容且不方便拆分。
  • 无法进行迭代Patch，不能直观预览资源信息。
  • 无法方便地管理工程和Patch版本。
  • 开发阶段无法方便地进行测试补丁打包。

具体操作是在Project Launcher中进行Release打包：

Cook时的命令：

1
UE4Editor-Cmd.exe "D:\ThirdPerson425\ThirdPerson425.uproject" -run=Cook  -TargetPlatform=WindowsNoEditor -fileopenlog -unversioned -createreleaseversion=1.0.0.0 -compressed -abslog="C:\Program Files\Epic Games\UE_4.25\Engine\Programs\AutomationTool\Saved\Cook-2021.03.19-19.00.30.txt" -stdout -CrashForUAT -unattended -NoLogTimes  -UTF8Output

当打包成功后会在项目的根目录中创建出一个Releases目录，存储以下文件：

1
2
3
4
5
6
7
8
9
D:\ThirdPerson425\Releases>tree /a /f
D:.
\---1.0.0.0
    \---WindowsNoEditor
        |   AssetRegistry.bin
        |   ThirdPerson425-WindowsNoEditor.pak
        |
        \---Metadata
                DevelopmentAssetRegistry.bin

可以看到它的实现实际上是备份了当前打包版本的AssetRegistry文件，但经过分析发现，它并不会用来和后续的版本做比对，使用的是另一种方式。

在基于某个Release进行Patch时会自动把AssetRegistry.bin和ushaderbytecode包含到pak中（并且shaderbytecode并没有进行patch）：

当基于某个基础版本进行Patch的时候，在Project Launher的设置如下：

执行流程中首先需要对项目进行Cook，但是Cook时不需要指定任何版本信息：

1
2
3
4
5
6
7
8
9
10
11
12
UE4Editor-Cmd.exe
 "D:\Project\ThirdPerson425.uproject"
 -run=Cook
 -TargetPlatform=WindowsNoEditor
 -fileopenlog
 -unversioned
 -abslog="C:\Program Files\Epic Games\UE_4.25\Engine\Programs\AutomationTool\Saved\Cook-2021.03.22-15.29.04.txt"
 -stdout
 -CrashForUAT
 -unattended
 -NoLogTimes
 -UTF8Output

当Cook完毕，执行Pak打包的时候，需要传入版本信息：

1
2
3
4
5
6
7
8
9
10
11
12
UnrealPak.exe
 "D:\Projects\ThirdPerson425.uproject"
 "D:\Projects\Package\1.0.0.0_patch1\WindowsNoEditor\ThirdPerson425\Content\Paks\ThirdPerson425-WindowsNoEditor_0_P.pak"
 -create="C:\Users\lipengzha\AppData\Roaming\Unreal Engine\AutomationTool\Logs\C+Program+Files+Epic+Games+UE_4.25\PakList_ThirdPerson425-WindowsNoEditor_0_P.txt"
 -cryptokeys="D:\Projects\Saved\Cooked\WindowsNoEditor\ThirdPerson425\Metadata\Crypto.json"
 -order="D:\Projects\Build\WindowsNoEditor\FileOpenOrder\CookerOpenOrder.log"
 -generatepatch="D:\Projects\Releases\1.0.0.0\WindowsNoEditor\ThirdPerson425-WindowsNoEditor*.pak"
 -tempfiles="C:\Program Files\Epic Games\UE_4.25\TempFilesThirdPerson425-WindowsNoEditor_0_P"
 -patchpaddingalign=2048
 -platform=Windows
 -multiprocess
 -abslog="C:\Users\lipengzha\AppData\Roaming\Unreal Engine\AutomationTool\Logs\C+Program+Files+Epic+Games+UE_4.25\UnrealPak-ThirdPerson425-WindowsNoEditor_0_P-2021.03.22-15.29.17.txt"

注意：

  1. -create=传递进去的Response的txt中是包含整个项目的资源列表的，并非是差异的文件列表。(-create=也可以传递pak文件，用来生成差异)
  2. 需要通过-generatepatch=传递基础包中的pak文件
  3. 读取基础版本包pak中所有文件，计算出每个文件的hash值
  4. 与Response中的资源进行比对，得到新加或者与基础包pak中Hash文件不同的文件列表
  5. 把差异部分打包至新的pak中。

执行时会加载基础包中pak的文件，计算pak中资源的hash值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
LogPakFile: Display: Parsing crypto keys from a crypto key cache file
LogPakFile: Display: Loading response file C:\Users\lipengzha\AppData\Roaming\Unreal Engine\AutomationTool\Logs\C+Program+Files+Epic+Games+UE_4.25\PakList_ThirdPerson425-WindowsNoEditor_0_P.txt
LogPakFile: Display: Added 1559 entries to add to pak file.
LogPakFile: Display: Loading pak order file C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson425\Build\WindowsNoEditor\FileOpenOrder\CookerOpenOrder.log...
LogPakFile: Display: Finished loading pak order file C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson425\Build\WindowsNoEditor\FileOpenOrder\CookerOpenOrder.log.
LogPakFile: Display: Generating patch from C:\Users\lipengzha\Documents\Unreal Projects\ThirdPerson425\Releases\1.0.0.0\WindowsNoEditor\ThirdPerson425-WindowsNoEditor*.pak.
LogPakFile: Display: Generated hash for "Engine/Content/Animation/DefaultAnimBoneCompressionSettings.uasset"
LogPakFile: Display: Generated hash for "Engine/Content/Animation/DefaultAnimCurveCompressionSettings.uasset"
LogPakFile: Display: Generated hash for "Engine/Content/Animation/DefaultAnimBoneCompressionSettings.uexp"
LogPakFile: Display: Generated hash for "Engine/Content/Animation/DefaultAnimCurveCompressionSettings.uexp"
LogPakFile: Display: Generated hash for "Engine/GlobalShaderCache-PCD3D_SM5.bin"
LogPakFile: Display: Generated hash for "Engine/Content/Functions/Engine_MaterialFunctions01/Opacity/CameraDepthFade.uasset"
LogPakFile: Display: Generated hash for "Engine/Content/Functions/Engine_MaterialFunctions01/Opacity/CameraDepthFade.uexp"
LogPakFile: Display: Generated hash for "Engine/Content/EngineMaterials/T_Default_Material_Grid_M.uasset"
LogPakFile: Display: Generated hash for "Engine/Content/EngineMaterials/T_Default_Material_Grid_N.uasset"
LogPakFile: Display: Generated hash for "Engine/Content/EngineMaterials/WorldGridMaterial.uasset"
LogPakFile: Display: Generated hash for "Engine/Content/EngineMaterials/DefaultMaterial.uasset"

生成hash的函数在GenerateHashesFromPak中，位于PakFileUtilities/Private/PakFileUtilities.cpp中。
其作用是：读取基础包中的文件，计算hash值，用作与新Cook之后的文件进行比对。

核心的代码在以下部分：

PakFileUtilities/Private/PakFileUtilities.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
bool ExecuteUnrealPak(const TCHAR* CmdLine)
{
  // ...

  // List of all items to add to pak file
  TArray<FPakInputPair> Entries;
  FPakCommandLineParameters CmdLineParameters;
  ProcessCommandLine(CmdLine, NonOptionArguments, Entries, CmdLineParameters);

  // ...

  if(NonOptionArguments.Num() > 0)
  {
    CheckAndReallocThreadPool();

    // since this is for creation, we pass true to make it not look in LaunchDir
    FString PakFilename = GetPakPath(*NonOptionArguments[0], true);

    // List of all items to add to pak file
    TArray<FPakInputPair> Entries;
    FPakCommandLineParameters CmdLineParameters;
    ProcessCommandLine(CmdLine, NonOptionArguments, Entries, CmdLineParameters);

    FPakOrderMap OrderMap;
    FString ResponseFile;
    if (FParse::Value(CmdLine, TEXT("-order="), ResponseFile) && !OrderMap.ProcessOrderFile(*ResponseFile))
    {
      return false;
    }

    FString SecondaryResponseFile;
    if (FParse::Value(CmdLine, TEXT("-secondaryOrder="), SecondaryResponseFile) && !OrderMap.ProcessOrderFile(*SecondaryResponseFile, true))
    {
      return false;
    }

    int32 LowestSourcePakVersion = 0;
    TMap<FString, FFileInfo> SourceFileHashes;

    if ( CmdLineParameters.GeneratePatch )
    {
      FString OutputPath;
      if (!FParse::Value(CmdLine, TEXT("TempFiles="), OutputPath))
      {
        OutputPath = FPaths::GetPath(PakFilename) / FString(TEXT("TempFiles"));
      }

      IFileManager::Get().DeleteDirectory(*OutputPath);

      // Check command line for the "patchcryptokeys" param, which will tell us where to look for the encryption keys that
      // we need to access the patch reference data
      FString PatchReferenceCryptoKeysFilename;
      FKeyChain PatchKeyChain;

      if (FParse::Value(FCommandLine::Get(), TEXT("PatchCryptoKeys="), PatchReferenceCryptoKeysFilename))
      {
        LoadKeyChainFromFile(PatchReferenceCryptoKeysFilename, PatchKeyChain);
        ApplyEncryptionKeys(PatchKeyChain);
      }

      UE_LOG(LogPakFile, Display, TEXT("Generating patch from %s."), *CmdLineParameters.SourcePatchPakFilename, true );

      if (!GenerateHashesFromPak(*CmdLineParameters.SourcePatchPakFilename, *PakFilename, SourceFileHashes, true, PatchKeyChain, /*Out*/LowestSourcePakVersion))
      {
        if (ExtractFilesFromPak(*CmdLineParameters.SourcePatchPakFilename, SourceFileHashes, *OutputPath, true, PatchKeyChain, nullptr) == false)
        {
          UE_LOG(LogPakFile, Warning, TEXT("Unable to extract files from source pak file for patch"));
        }
        else
        {
          CmdLineParameters.SourcePatchDiffDirectory = OutputPath;
        }
      }

      ApplyEncryptionKeys(KeyChain);
    }


    // Start collecting files
    TArray<FPakInputPair> FilesToAdd;
    CollectFilesToAdd(FilesToAdd, Entries, OrderMap, CmdLineParameters);

    if ( CmdLineParameters.GeneratePatch )
    {
      // We need to get a list of files that were in the previous patch('s) Pak, but NOT in FilesToAdd
      TArray<FPakInputPair> DeleteRecords = GetNewDeleteRecords(FilesToAdd, SourceFileHashes);

      //if the patch is built using old source pak files, we need to handle the special case where a file has been moved between chunks but no delete record was created (this would cause a rogue delete record to be created in the latest pak), and also a case where the file was moved between chunks and back again without being changed (this would cause the file to not be included in this chunk because the file would be considered unchanged)
      if (LowestSourcePakVersion < FPakInfo::PakFile_Version_DeleteRecords)
      {
        int32 CurrentPatchChunkIndex = GetPakChunkIndexFromFilename(PakFilename);

        UE_LOG(LogPakFile, Display, TEXT("Some patch source paks were generated with an earlier version of UnrealPak that didn't support delete records. checking for historic assets that have moved between chunks to avoid creating invalid delete records"));
        FString SourcePakFolder = FPaths::GetPath(CmdLineParameters.SourcePatchPakFilename);

        //remove invalid items from DeleteRecords and set 'bForceInclude' on some SourceFileHashes
        ProcessLegacyFileMoves(DeleteRecords, SourceFileHashes, SourcePakFolder, FilesToAdd, CurrentPatchChunkIndex);
      }
      FilesToAdd.Append(DeleteRecords);

      // if we are generating a patch here we remove files which are already shipped...
      RemoveIdenticalFiles(FilesToAdd, CmdLineParameters.SourcePatchDiffDirectory, SourceFileHashes, CmdLineParameters.SeekOptParams, CmdLineParameters.ChangedFilesOutputFilename);
    }


    bool bResult = CreatePakFile(*PakFilename, FilesToAdd, CmdLineParameters, KeyChain);

    if (CmdLineParameters.GeneratePatch)
    {
      FString OutputPath = FPaths::GetPath(PakFilename) / FString(TEXT("TempFiles"));
      // delete the temporary directory
      IFileManager::Get().DeleteDirectory(*OutputPath, false, true);
    }

    GetDerivedDataCacheRef().WaitForQuiescence(true);

    return bResult;
  }

}

通过分析UE的Patch机制可以知道，它的版本比对比较粗暴，是直接得到Pak中文件的二进制信息计算Hash值与当前工程中Cook之后的HASH值来进行比对的，本质上就是基于二进制的比对，这就需要管理好DDC等COOK之后生成的文件，我觉得这样是不合理的，所以HotPatcher是基于原始资源的GUID的比对。

配置ConsoleVariable默认值

有时候需要在打包时设定某些控制台变量的默认值，可以通过以下方式来设置：

DefaultEngine.ini
1
2
[ConsoleVariables]
pakcache.Enable=0

引擎中的相关代码为：

Engine\Source\Runtime\Core\Private\Misc\ConfigCacheIni.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void FConfigCacheIni::LoadConsoleVariablesFromINI()
{
  FString ConsoleVariablesPath = FPaths::EngineDir() + TEXT("Config/ConsoleVariables.ini");

#if !DISABLE_CHEAT_CVARS
  // First we read from "../../../Engine/Config/ConsoleVariables.ini" [Startup] section if it exists
  // This is the only ini file where we allow cheat commands (this is why it's not there for UE_BUILD_SHIPPING || UE_BUILD_TEST)
  ApplyCVarSettingsFromIni(TEXT("Startup"), *ConsoleVariablesPath, ECVF_SetByConsoleVariablesIni, true);
#endif // !DISABLE_CHEAT_CVARS

  // We also apply from Engine.ini [ConsoleVariables] section
  ApplyCVarSettingsFromIni(TEXT("ConsoleVariables"), *GEngineIni, ECVF_SetBySystemSettingsIni);

  IConsoleManager::Get().CallAllConsoleVariableSinks();
}

默认会读取Engine/Config/ConsoleVariables.ini的[Startup]和GEngineIni（Engine/Config/BaseEngine.ini/{PROJECT}/Config/DefaultEngine.ini/{PROJECT}/Config/{PLATFORM}/{PLATFORM}Engine.ini）中的[ConsoleVariables]中的配置。

UPROPERTY的ConsoleVariable

成员属性可以绑定到某个控制台变量：

RendererSettings.h
1
2
3
4
5
6
7
8
/**
  "Skin cache allows a compute shader to skin once each vertex, save those results into a new buffer and reuse those calculations when later running the depth, base and velocity passes. This also allows opting into the 'recompute tangents' for skinned mesh instance feature. Disabling will reduce the number of shader permutations required per material. Changing this setting requires restarting the editor."
  */
UPROPERTY(config, EditAnywhere, Category = Optimizations, meta = (
  ConsoleVariable = "r.SkinCache.CompileShaders", DisplayName = "Support Compute Skin Cache",
  ToolTip = "Cannot be disabled while Ray Tracing is enabled as it is then required.",
  ConfigRestartRequired = true))
uint32 bSupportSkinCacheShaders : 1;

定义在其他文件中的FAutoConsoleVariableRef：

GPUSkinCache.cpp
1
2
3
4
5
6
7
8
9
10
11
static int32 GEnableGPUSkinCacheShaders = 0;

static FAutoConsoleVariableRef CVarEnableGPUSkinCacheShaders(
  TEXT("r.SkinCache.CompileShaders"),
  GEnableGPUSkinCacheShaders,
  TEXT("Whether or not to compile the GPU compute skinning cache shaders.\n")
  TEXT("This will compile the shaders for skinning on a compute job and not skin on the vertex shader.\n")
  TEXT("GPUSkinVertexFactory.usf needs to be touched to cause a recompile if this changes.\n")
  TEXT("0 is off(default), 1 is on"),
  ECVF_RenderThreadSafe | ECVF_ReadOnly
);

代码编译时执行脚本

在插件的uplugin文件中可以写入PreBuildSteps/PostBuildSteps以下两个元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
{
  "PostBuildSteps":
  {
    "Win64":
    [
      "\"$(PluginDir)\\Source\\AkAudio\\WwisePostBuildSteps.bat\" \"$(EngineDir)\\Binaries\\Win64\\UE4Editor-cmd.exe\" \"$(ProjectFile)\" $(TargetType) -run=AkPluginActivator -platform=$(TargetPlatform) -configuration=Profile -targetconfig=$(TargetConfiguration)"
    ],
    "PS4":
    [
      "\"$(PluginDir)\\Source\\AkAudio\\WwisePostBuildSteps.bat\" \"$(EngineDir)\\Binaries\\Win64\\UE4Editor-cmd.exe\" \"$(ProjectFile)\" -run=AkPluginActivator -platform=$(TargetPlatform) -configuration=Profile -targetconfig=$(TargetConfiguration)"
    ]
  }
}

可以在构建时指定自动执行一个脚本，用来处理一些特殊的功能。

ProjectDescriptor的声明：Source\Programs\UnrealBuildTool\System\ProjectDescriptor.cs

在UBT的Source\Programs\UnrealBuildTool\Configuration\UEBuildTarget.cs中被解析:

Source\Programs\UnrealBuildTool\Configuration\UEBuildTarget.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
/// <summary>
/// Creates scripts for executing the pre-build scripts
/// </summary>
public FileReference[] CreatePreBuildScripts() {
  // Find all the pre-build steps
  List < Tuple < string[],
  UEBuildPlugin >> PreBuildCommandBatches = new List < Tuple < string[],
  UEBuildPlugin >> ();
  if (ProjectDescriptor != null && ProjectDescriptor.PreBuildSteps != null) {
    AddCustomBuildSteps(ProjectDescriptor.PreBuildSteps, null, PreBuildCommandBatches);
  }
  if (Rules.PreBuildSteps.Count > 0) {
    PreBuildCommandBatches.Add(new Tuple < string[], UEBuildPlugin > (Rules.PreBuildSteps.ToArray(), null));
  }
  foreach(UEBuildPlugin BuildPlugin in BuildPlugins.Where(x =>x.Descriptor.PreBuildSteps != null)) {
    AddCustomBuildSteps(BuildPlugin.Descriptor.PreBuildSteps, BuildPlugin, PreBuildCommandBatches);
  }
  return WriteCustomBuildStepScripts(BuildHostPlatform.Current.Platform, ProjectIntermediateDirectory, "PreBuild", PreBuildCommandBatches);
}

/// <summary>
/// Creates scripts for executing post-build steps
/// </summary>
/// <returns>Array of post-build scripts</returns>
private FileReference[] CreatePostBuildScripts() {
  // Find all the post-build steps
  List < Tuple < string[],
  UEBuildPlugin >> PostBuildCommandBatches = new List < Tuple < string[],
  UEBuildPlugin >> ();
  if (!Rules.bDisableLinking) {
    if (ProjectDescriptor != null && ProjectDescriptor.PostBuildSteps != null) {
      AddCustomBuildSteps(ProjectDescriptor.PostBuildSteps, null, PostBuildCommandBatches);
    }
    if (Rules.PostBuildSteps.Count > 0) {
      PostBuildCommandBatches.Add(new Tuple < string[], UEBuildPlugin > (Rules.PostBuildSteps.ToArray(), null));
    }
    foreach(UEBuildPlugin BuildPlugin in BuildPlugins.Where(x =>x.Descriptor.PostBuildSteps != null)) {
      AddCustomBuildSteps(BuildPlugin.Descriptor.PostBuildSteps, BuildPlugin, PostBuildCommandBatches);
    }
  }
  return WriteCustomBuildStepScripts(BuildHostPlatform.Current.Platform, ProjectIntermediateDirectory, "PostBuild", PostBuildCommandBatches);
}

/// <summary>
/// Adds custom build steps from the given JSON object to the list of command batches
/// </summary>
/// <param name="BuildSteps">The custom build steps</param>
/// <param name="Plugin">The plugin to associate with these commands</param>
/// <param name="CommandBatches">List to receive the command batches</param>
private void AddCustomBuildSteps(CustomBuildSteps BuildSteps, UEBuildPlugin Plugin, List < Tuple < string[], UEBuildPlugin >> CommandBatches) {
  string[] Commands;
  if (BuildSteps.TryGetCommands(BuildHostPlatform.Current.Platform, out Commands)) {
    CommandBatches.Add(Tuple.Create(Commands, Plugin));
  }
}

/// <summary>
/// Write scripts containing the custom build steps for the given host platform
/// </summary>
/// <param name="HostPlatform">The current host platform</param>
/// <param name="Directory">The output directory for the scripts</param>
/// <param name="FilePrefix">Bare prefix for all the created script files</param>
/// <param name="CommandBatches">List of custom build steps, and their matching PluginInfo (if appropriate)</param>
/// <returns>List of created script files</returns>
private FileReference[] WriteCustomBuildStepScripts(UnrealTargetPlatform HostPlatform, DirectoryReference Directory, string FilePrefix, List < Tuple < string[], UEBuildPlugin >> CommandBatches) {
  List < FileReference > ScriptFiles = new List < FileReference > ();
  foreach(Tuple < string[], UEBuildPlugin > CommandBatch in CommandBatches) {
    // Find all the standard variables
    Dictionary < string,
    string > Variables = GetTargetVariables(CommandBatch.Item2);

    // Get the output path to the script
    string ScriptExtension = (HostPlatform == UnrealTargetPlatform.Win64) ? ".bat": ".sh";
    FileReference ScriptFile = FileReference.Combine(Directory, String.Format("{0}-{1}{2}", FilePrefix, ScriptFiles.Count + 1, ScriptExtension));

    // Write it to disk
    List < string > Contents = new List < string > ();
    if (HostPlatform == UnrealTargetPlatform.Win64) {
      Contents.Insert(0, "@echo off");
    }
    foreach(string Command in CommandBatch.Item1) {
      Contents.Add(Utils.ExpandVariables(Command, Variables));
    }
    if (!DirectoryReference.Exists(ScriptFile.Directory)) {
      DirectoryReference.CreateDirectory(ScriptFile.Directory);
    }
    File.WriteAllLines(ScriptFile.FullName, Contents);

    // Add the output file to the list of generated scripts
    ScriptFiles.Add(ScriptFile);
  }
  return ScriptFiles.ToArray();
}

在编译代码之后会执行指定的脚本，会有以下Log：

1
2>8> Exec: PostBuild-1.bat.ran

注意：测试中发现如果插件的代码没有变动，它不会执行。

CopyDirectory

可以使用UE中的IPlatformFile::CopyDirectoryTree，但是注意调用之前要保证两个目标路径都存在：

1
2
3
IPlatformFile& PlatformFile = FPlatformFileManager::Get().GetPlatformFile();
PlatformFile.CreateDirectoryTree(*OutMetadir);
PlatformFile.CopyDirectoryTree(*OutMetadir,*MetadataDir,true);

UE4快捷键

Windows.h造成的名字冲突

有时候需要包含一些平台相关的代码，如windows.h里面包含了很多头文件，其中一些定义了很多宏，如：

fileapi.h
1
2
3
4
5
#ifdef UNICODE
#define DeleteFile  DeleteFileW
#else
#define DeleteFile  DeleteFileA
#endif // !UNICODE

如果我们同时在代码中包含了windows.h和使用了IPlatformFile的接口来调用它的DeleteFile函数，因为DeleteFile被定义成了宏，所以在预处理阶段就会被替换，导致编译时访问IPlatformFile的DeleteFileW成员，但实际上它是不存在的，就产生了以下编译错误：

1
error C2039: 'DeleteFileW': is not a member of 'IPlatformFile'

解决办法就是不直接包含windows.h而是使用以下封装：

1
2
3
#include "Windows/AllowWindowsPlatformTypes.h"
#include "windows.h"
#include "Windows/HideWindowsPlatformTypes.h"

这样可以避免污染UE的符号名字。

UE的文档中也有介绍：第三方库#故障排除

Core Redirects

有时候Class/Enums/functions/packages/property/struct被改了名字，导致所有引用到它们的资源都要手动修改一遍，非常麻烦。

为了解决这个问题，UE提供了重定向功能，可以在不变动大量资源的情况下进行重定向到新的资源。

打包时Shader的编译

UE打包项目时并不是所有的shader都会被编译到ushaderbytecode中的，只有打包进去的才会编译进去。
进行了一个测试：

  1. 把/Game添加到了Directories to Never Cook
  2. 打包工程到Android

最终编译出来的ushaderbytecode的大小为：

在UE打包时会拉起Cook进行执行资源的Cook和Shader的编译，应该是在当前的Cook进程中编译的Shader最终会写入到ushaderbytecode文件中，没有被执行Cook的资源不会被编译Shader，从而实现了不会把没有用到的Shader打包的行为。

不过以上只是猜测，有时间具体分析下Cook和Shader编译相关的代码。

DDC共享

共享DDC的作用是：当同一网络内共享DDC的人只要有一个人编译了DDC，其他人就无需重新编译，节省Shader的编译时间，提高效率。

所以，一般情况下只需要在局域网内部署一个高IO吞吐的机器，每个人都把该机器的共享目录挂载到本地，就可以实现DDC的共享，因为DDC的目录是相对于网络路径的，所以每个人的修改都会影响到其他人，从而实现一个编译多人共享的效果。

UE的文档里介绍了三种设置的方法：

  1. 修改DefaultEngine.ini添加DerivedDataBackendGraph项；
  2. 系统中添加UE-SharedDataCachePath环境变量；
  3. 在UE的Editor Preferences-Global-Shared Derived Data Cache设置共享的DDC目录；

UE推荐的是使用第一种方法，但是具体实践和文档中介绍的略有不同。

对于源码版引擎，使用DDC文档中介绍的第一种方法，在项目的DefaultEngine.ini中添加以下项：

DefaultEngine.ini
1
2
[DerivedDataBackendGraph]
Shared=(Type=FileSystem, ReadOnly=false, Clean=false, Flush=false, DeleteUnused=true, UnusedFileAge=10, FoldersToClean=10, MaxFileChecksPerSec=1, ConsiderSlowAt=70, PromptIfMissing=false, Path=\\YourDDCServer\DDC, EnvPathOverride=UE-SharedDataCachePath, EditorOverrideSetting=SharedDerivedDataCache)

但是对于安装版引擎（Installed），要把DerivedDataBackendGraph改成InstalledDerivedDataBackendGraph：

DefaultEngine.ini
1
2
[InstalledDerivedDataBackendGraph]
Shared=(Type=FileSystem, ReadOnly=false, Clean=false, Flush=false, DeleteUnused=true, UnusedFileAge=10, FoldersToClean=10, MaxFileChecksPerSec=1, ConsiderSlowAt=70, PromptIfMissing=false, Path=\\YourDDCServer\FMGame\DDC, EnvPathOverride=UE-SharedDataCachePath, EditorOverrideSetting=SharedDerivedDataCache)

这是因为引擎在Developer/DerivedDataCache/Private/DerivedDataBackends.cpp中对安装版和源码版做了区分：

1
2
3
4
5
6
7
8
9
10
11
FDerivedDataBackendGraph()
  // ...
{
    // ...
  if( !RootCache )
  {
    // Use default graph
    GraphName = FApp::IsEngineInstalled() ? TEXT("InstalledDerivedDataBackendGraph") : TEXT("DerivedDataBackendGraph");
    // ...
  }
};

在设置完之后就可以通过Commandlet来执行DDC的生成了：

1
Engine\Binaries\Win64\UE4Editor.exe Client\Client.uproject -run=DerivedDataCache -fill

该Commandlet定义在Editor/UnrealEd/Classes/Commandlets/DerivedDataCacheCommandlet.h。

如果想要在配置文件添加之后关闭掉DDC，可以在Editor启动时添加参数-ddc=noshared。

.target文件

UE编译项目（Game/Program等）的时候会生成该项目的target文件，记录了该项目的文件依赖，以UHT为例

UnrealHeaderTool.target
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
{
  "TargetName": "UnrealHeaderTool",
  "Platform": "Win64",
  "Configuration": "Development",
  "TargetType": "Program",
  "Architecture": "",
  "Launch": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool.exe",
  "Version": 
  {
    "MajorVersion": 4,
    "MinorVersion": 25,
    "PatchVersion": 1,
    "Changelist": 0,
    "CompatibleChangelist": 13144385,
    "IsLicenseeVersion": 0,
    "IsPromotedBuild": 0,
    "BranchName": "++UE4+Release-4.25",
    "BuildId": "b5ff8f70-3501-456c-bde4-438215a9b5c5",
    "BuildVersion": ""
  },
  "BuildProducts": [
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool.exe",
      "Type": "Executable"
    },
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool.pdb",
      "Type": "SymbolFile"
    },
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool-BuildSettings.dll",
      "Type": "DynamicLibrary"
    },
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool-BuildSettings.pdb",
      "Type": "SymbolFile"
    },
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool-TraceLog.dll",
      "Type": "DynamicLibrary"
    },
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool-TraceLog.pdb",
      "Type": "SymbolFile"
    },
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool-Core.dll",
      "Type": "DynamicLibrary"
    },
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool-Core.pdb",
      "Type": "SymbolFile"
    },
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool-Json.dll",
      "Type": "DynamicLibrary"
    },
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool-Json.pdb",
      "Type": "SymbolFile"
    },
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool-Projects.dll",
      "Type": "DynamicLibrary"
    },
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool-Projects.pdb",
      "Type": "SymbolFile"
    },
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool-CoreUObject.dll",
      "Type": "DynamicLibrary"
    },
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool-CoreUObject.pdb",
      "Type": "SymbolFile"
    },
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool.version",
      "Type": "RequiredResource"
    },
    {
      "Path": "$(EngineDir)/Binaries/Win64/UnrealHeaderTool.modules",
      "Type": "RequiredResource"
    }
  ],
  "RuntimeDependencies": [
    {
      "Path": "$(EngineDir)/Binaries/ThirdParty/DbgHelp/dbghelp.dll",
      "Type": "NonUFS"
    }
  ],
  "AdditionalProperties": [
    {
      "Name": "SDK",
      "Value": "Not Applicable"
    }
  ]
}

基于这个文件列表，可以实现自动提取程序依赖的功能，在想要提取UE的Program类型的程序时很有用。

IOS Crash分析文档

材质Sampler超限制Crash

打包Android运行时发现一个Crash问题：

1
2
3
4
[2021.02.26-06.24.25:291][593]LogRHI: Error: Failed to link program. Current total programs: 112 program binary bytes: 1786425
  log:
Error: Sampler Sampler location or component exceeds max allowed.
Error: Linking failed.

该错误执行在Runtime/OpenGLDrv/Private/OpenGLShaders.cpp中。

原因是某些材质的Sampler超了限制，导致错误。

排查方法为：打开材质，查看在平台中的Sampler的数量：

DoesPackageExists分析

1
2
3
4
5
6
7
8
9
10
11
12
13
class COREUOBJECT_API FPackageName
{
public:
  /**
   * Checks if the package exists on disk.
   * 
   * @param LongPackageName Package name.
   * @param OutFilename Package filename on disk.
   * @param InAllowTextFormats Detect text format packages as well as binary (priority to text)
   * @return true if the specified package name points to an existing package, false otherwise.
   **/
  static bool DoesPackageExist(const FString& LongPackageName, const FGuid* Guid = NULL, FString* OutFilename = NULL, bool InAllowTextFormats = true);
};

该函数用来检测Package是否在磁盘上存在。

注意：在磁盘上存在在UE里有两个情况：

  1. Editor下存在uasset文件
  2. 打包模式下uasset是否在Mounted的Pak中存在

事实上，UE也是这么做检测的：

  1. 首先把要检测的LongPackageName根据规则转换为文件路径
  2. 通过FileManager来检测文件路径是否存在

在Editor和打包模式下，FileManager通过GetLowLevel()拿到IPlatformFile，之后再进行FileExist的检测，UE针对各个平台封装了IPlatformFile，而且也具有PakPlatformFile的实现，可以实现从Pak中读取文件与在普通文件系统中访问一样的接口。


UE的跨平台写法，声明在通用接口里，定义在各个平台的单独文件中：

在引擎启动时会把这些IPlatformFile的对象创建：

Runtime/Launch/Private/LaunchEngineLoop.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
/**
 * Look for any file overrides on the command line (i.e. network connection file handler)
 */
bool LaunchCheckForFileOverride(const TCHAR* CmdLine, bool& OutFileOverrideFound)
{
  OutFileOverrideFound = false;

  // Get the physical platform file.
  IPlatformFile* CurrentPlatformFile = &FPlatformFileManager::Get().GetPlatformFile();

  // Try to create pak file wrapper
  {
    IPlatformFile* PlatformFile = ConditionallyCreateFileWrapper(TEXT("PakFile"), CurrentPlatformFile, CmdLine);
    if (PlatformFile)
    {
      CurrentPlatformFile = PlatformFile;
      FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
    }
    PlatformFile = ConditionallyCreateFileWrapper(TEXT("CachedReadFile"), CurrentPlatformFile, CmdLine);
    if (PlatformFile)
    {
      CurrentPlatformFile = PlatformFile;
      FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
    }
  }

  // Try to create sandbox wrapper
  {
    IPlatformFile* PlatformFile = ConditionallyCreateFileWrapper(TEXT("SandboxFile"), CurrentPlatformFile, CmdLine);
    if (PlatformFile)
    {
      CurrentPlatformFile = PlatformFile;
      FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
    }
  }

#if !UE_BUILD_SHIPPING // UFS clients are not available in shipping builds.
  // Streaming network wrapper (it has a priority over normal network wrapper)
  bool bNetworkFailedToInitialize = false;
  do
  {
    bool bShouldUseStreamingFile = false;
    IPlatformFile* NetworkPlatformFile = ConditionallyCreateFileWrapper(TEXT("StreamingFile"), CurrentPlatformFile, CmdLine, &bNetworkFailedToInitialize, &bShouldUseStreamingFile);
    if (NetworkPlatformFile)
    {
      CurrentPlatformFile = NetworkPlatformFile;
      FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
    }

    bool bShouldUseCookedIterativeFile = false;
    if ( !bShouldUseStreamingFile && !NetworkPlatformFile )
    {
      NetworkPlatformFile = ConditionallyCreateFileWrapper(TEXT("CookedIterativeFile"), CurrentPlatformFile, CmdLine, &bNetworkFailedToInitialize, &bShouldUseCookedIterativeFile);
      if (NetworkPlatformFile)
      {
        CurrentPlatformFile = NetworkPlatformFile;
        FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
      }
    }

    // if streaming network platform file was tried this loop don't try this one
    // Network file wrapper (only create if the streaming wrapper hasn't been created)
    if ( !bShouldUseStreamingFile && !bShouldUseCookedIterativeFile && !NetworkPlatformFile)
    {
      NetworkPlatformFile = ConditionallyCreateFileWrapper(TEXT("NetworkFile"), CurrentPlatformFile, CmdLine, &bNetworkFailedToInitialize);
      if (NetworkPlatformFile)
      {
        CurrentPlatformFile = NetworkPlatformFile;
        FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
      }
    }

    if (bNetworkFailedToInitialize)
    {
      FString HostIpString;
      FParse::Value(CmdLine, TEXT("-FileHostIP="), HostIpString);
#if PLATFORM_REQUIRES_FILESERVER
      FPlatformMisc::LowLevelOutputDebugStringf(TEXT("Failed to connect to file server at %s. RETRYING in 5s.\n"), *HostIpString);
      FPlatformProcess::Sleep(5.0f);
      uint32 Result = 2;
#else //PLATFORM_REQUIRES_FILESERVER
      // note that this can't be localized because it happens before we connect to a filserver - localizing would cause ICU to try to load.... from over the file server connection!
      FString Error = FString::Printf(TEXT("Failed to connect to any of the following file servers:\n\n    %s\n\nWould you like to try again? No will fallback to local disk files, Cancel will quit."), *HostIpString.Replace( TEXT("+"), TEXT("\n    ")));
      uint32 Result = FMessageDialog::Open( EAppMsgType::YesNoCancel, FText::FromString( Error ) );
#endif  //PLATFORM_REQUIRES_FILESERVER

      if (Result == EAppReturnType::No)
      {
        break;
      }
      else if (Result == EAppReturnType::Cancel)
      {
        // Cancel - return a failure, and quit
        return false;
      }
    }
  }
  while (bNetworkFailedToInitialize);
#endif

#if !UE_BUILD_SHIPPING
  // Try to create file profiling wrapper
  {
    IPlatformFile* PlatformFile = ConditionallyCreateFileWrapper(TEXT("ProfileFile"), CurrentPlatformFile, CmdLine);
    if (PlatformFile)
    {
      CurrentPlatformFile = PlatformFile;
      FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
    }
  }
  {
    IPlatformFile* PlatformFile = ConditionallyCreateFileWrapper(TEXT("SimpleProfileFile"), CurrentPlatformFile, CmdLine);
    if (PlatformFile)
    {
      CurrentPlatformFile = PlatformFile;
      FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
    }
  }
  // Try and create file timings stats wrapper
  {
    IPlatformFile* PlatformFile = ConditionallyCreateFileWrapper(TEXT("FileReadStats"), CurrentPlatformFile, CmdLine);
    if (PlatformFile)
    {
      CurrentPlatformFile = PlatformFile;
      FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
    }
  }
  // Try and create file open log wrapper (lists the order files are first opened)
  {
    IPlatformFile* PlatformFile = ConditionallyCreateFileWrapper(TEXT("FileOpenLog"), CurrentPlatformFile, CmdLine);
    if (PlatformFile)
    {
      CurrentPlatformFile = PlatformFile;
      FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
    }
  }
#endif  //#if !UE_BUILD_SHIPPING

  // Wrap the above in a file logging singleton if requested
  {
    IPlatformFile* PlatformFile = ConditionallyCreateFileWrapper(TEXT("LogFile"), CurrentPlatformFile, CmdLine);
    if (PlatformFile)
    {
      CurrentPlatformFile = PlatformFile;
      FPlatformFileManager::Get().SetPlatformFile(*CurrentPlatformFile);
    }
  }

  // If our platform file is different than it was when we started, then an override was used
  OutFileOverrideFound = (CurrentPlatformFile != &FPlatformFileManager::Get().GetPlatformFile());

  return true;
}

LoadObject加载磁盘文件栈

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
FFileManagerGeneric::CreateFileReaderInternal(const wchar_t *,unsigned int,unsigned int) FileManagerGeneric.cpp:47
FLinkerLoad::CreateLoader(TFunction<void __cdecl(void)> &&) LinkerLoad.cpp:1037
FLinkerLoad::Tick(float,bool,bool,TMap<TTuple<FName,FPackageIndex>,FPackageIndex,FDefaultSetAllocator,TDefaultMapHashableKeyFuncs<TTuple<FName,FPackageIndex>,FPackageIndex,0> > *) LinkerLoad.cpp:696
FLinkerLoad::CreateLinker(FUObjectSerializeContext *,UPackage *,const wchar_t *,unsigned int,FArchive *) LinkerLoad.cpp:459
GetPackageLinker(UPackage *,const wchar_t *,unsigned int,UPackageMap *,FGuid *,FArchive *,FUObjectSerializeContext **) Linker.cpp:745
LoadPackageInternal(UPackage *,const wchar_t *,unsigned int,FLinkerLoad *,FArchive *,FUObjectSerializeContext *) UObjectGlobals.cpp:1208
LoadPackage(UPackage *,const wchar_t *,unsigned int,FArchive *,FUObjectSerializeContext *) UObjectGlobals.cpp:1427
ResolveName(UObject *&,FString &,bool,bool,unsigned int,FUObjectSerializeContext *) UObjectGlobals.cpp:767
StaticLoadObjectInternal(UClass *,UObject *,const wchar_t *,const wchar_t *,unsigned int,UPackageMap *,bool,FUObjectSerializeContext *) UObjectGlobals.cpp:828
StaticLoadObject(UClass *,UObject *,const wchar_t *,const wchar_t *,unsigned int,UPackageMap *,bool,FUObjectSerializeContext *) UObjectGlobals.cpp:904
FSoftObjectPath::TryLoad(FUObjectSerializeContext *) SoftObjectPath.cpp:431
FSoftObjectPtr::LoadSynchronous() SoftObjectPtr.h:54
UPaperSprite::GetSourceTexture() PaperSprite.cpp:1474
UPaperSprite::PostLoad() PaperSprite.cpp:1842
UObject::ConditionalPostLoad() Obj.cpp:1067
FAsyncPackage::PostLoadObjects() AsyncLoading.cpp:6356
FAsyncPackage::TickAsyncPackage(bool,bool,float &,FFlushTree *) AsyncLoading.cpp:5533
FAsyncLoadingThread::ProcessAsyncLoading(int &,bool,bool,float,FFlushTree *) AsyncLoading.cpp:4178
FAsyncLoadingThread::TickAsyncThread(bool,bool,float,bool &,FFlushTree *) AsyncLoading.cpp:4819
FAsyncLoadingThread::TickAsyncLoading(bool,bool,float,FFlushTree *) AsyncLoading.cpp:4519
FAsyncLoadingThread::ProcessLoading(bool,bool,float) AsyncLoading.cpp:7057
StaticTick(float,bool,float) UObjectGlobals.cpp:464
UEditorEngine::Tick(float,bool) EditorEngine.cpp:1355
UUnrealEdEngine::Tick(float,bool) UnrealEdEngine.cpp:411
FEngineLoop::Tick() LaunchEngineLoop.cpp:4844
GuardedMain(const wchar_t *) Launch.cpp:171
WinMain(HINSTANCE__ *,HINSTANCE__ *,char *,int) LaunchWindows.cpp:257
__scrt_common_main_seh() 0x00007ff6ab4e140a
BaseThreadInitThunk 0x00007ffabeff7c24
RtlUserThreadStart 0x00007ffabfcad4d1

rebuild metadata

可以通过执行cook的Commandlet来重新生成AssetRegistry以及ushaderbytecode：

1
UE4Editor-cmd.exe PROJECT_NAME.uproject -run=cook -targetplatform=WindowsNoEditor -Iterate -UnVersioned -Compressed

执行完毕之后Saved/Cooked下的AssetRegistry.bin/Metadate目录/Content/ShaderArchive-*.ushaderbytecode以及Ending/GlobalShaderCache*.bin等文件都是生成之后最新的了，可以在之后通过HotPatcher来打包他们了。

IPA包最大为4GB

自动化Editor的Crash上报

因为UE的Crash是拉起一个CrashReportClient程序来执行的，所以如果我们需要在程序出现Crash时上报log信息，可以在CrashReportClientMainWindows中做这部分逻辑。

监听资源创建

在Editor中创建资源，并没有直接保存到磁盘上，所以要监听OnInMemoryAssetCreated：

1
2
3
FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(
    TEXT("AssetRegistry"));
  AssetRegistryModule.Get().OnInMemoryAssetCreated().AddRaw(this, &FTestEditorModule::OnInMemoryAssetCreated);

回调过来的就是一个UObject*，实际上是一个UBlueprint*：

1
2
3
4
5
6
7
8
void FTestEditorModule::OnInMemoryAssetCreated(UObject* Object)
{
  if (nullptr == Object) return;

  UBlueprint* Blueprint = Cast<UBlueprint>(Object);
  if (nullptr == Blueprint) return;
  // ...
}

可以实现监听uasset创建事件，对该uasset执行一些操作（如默认添加接口等）。

拿到UBlueprint后就可以通过FBlueprintEditorUtils等辅助类来实现对蓝图资源的操作了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
bool FTestEditor::AddInterface(UBlueprint* Blueprint)
{
  if (nullptr == Blueprint) return false;

  UClass* Class = Blueprint ? *Blueprint->GeneratedClass : Blueprint ? Blueprint->GetClass() : NULL;
  if (nullptr == Class) return false;

  if (!Class->IsChildOf<UUserWidget>()) return false;

  static UClass* InterfaceClass = UUnLuaInterface::StaticClass();

  UFunction* Func = FBlueprintEditorUtils::GetInterfaceFunction(Blueprint, FName("GetModuleName"));
  if (nullptr == Func)
  {
    FBlueprintEditorUtils::ImplementNewInterface(Blueprint, InterfaceClass->GetFName());
  }

  Func = FBlueprintEditorUtils::GetInterfaceFunction(Blueprint, FName("GetModuleName"));
  if (nullptr == Func) return false;

  auto ImplementedInterfaces = Blueprint->ImplementedInterfaces;
  if (ImplementedInterfaces.Num() <= 0) return false;

  auto InterfacesDesc = ImplementedInterfaces[0];

  auto Graphs = InterfacesDesc.Graphs;
  if (Graphs.Num() <= 0) return false;

  auto Graph = Graphs[0]; //UEdGraph
  if (nullptr == Graph) return false;

  auto Nodes = Graph->Nodes;
  if (Nodes.Num() <= 0) return false;

  auto Node = Nodes[1]; //UEdGraphNode
  if (nullptr == Node) return false;

  auto Pins = Node->Pins;
  if (Pins.Num() <= 0) return false;

  auto Pin = Pins[1]; //UEdGraphPin
  if (nullptr == Pin) return false;

  FString moduleName;
  UnLuaExtensionUtils::GetLuaModuleName(Class->GetName(), Class->GetPathName(), moduleName);

  Pin->DefaultValue = moduleName;

  return true;
}

Build lighting from commandlet

在命令行构建光照，可以使用ResavePackages这个commandlet：

1
UE4Editor-cmd.exe "E:\UE4Project.uproject" -run=resavepackages -buildlighting -quality=Preview -allowcommandletrendering -map=MapName

AutomationTool的ErrorCode

打包时的错误，可以通过这些错误码的描述来排查原因，该enum定义在Programs/AutomationTool/AutomationUtils/AutomationException.cs。

Programs/AutomationTool/AutomationUtils/AutomationException.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
namespace AutomationTool
{
  // NOTE: this needs to be kept in sync with EditorAnalytics.h and iPhonePackager.cs
  public enum ExitCode
    {
        Error_UATNotFound = -1,
        Success = 0,
        Error_Unknown = 1,
        Error_Arguments = 2,
        Error_UnknownCommand = 3,
        Error_SDKNotFound = 10,
        Error_ProvisionNotFound = 11,
        Error_CertificateNotFound = 12,
        Error_ProvisionAndCertificateNotFound = 13,
        Error_InfoPListNotFound = 14,
        Error_KeyNotFoundInPList = 15,
        Error_ProvisionExpired = 16,
        Error_CertificateExpired = 17,
        Error_CertificateProvisionMismatch = 18,
        Error_CodeUnsupported = 19,
        Error_PluginsUnsupported = 20,
        Error_UnknownCookFailure = 25,
        Error_UnknownDeployFailure = 26,
        Error_UnknownBuildFailure = 27,
        Error_UnknownPackageFailure = 28,
        Error_UnknownLaunchFailure = 29,
        Error_StageMissingFile = 30,
        Error_FailedToCreateIPA = 31,
        Error_FailedToCodeSign = 32,
        Error_DeviceBackupFailed = 33,
        Error_AppUninstallFailed = 34,
        Error_AppInstallFailed = 35,
        Error_AppNotFound = 36,
        Error_StubNotSignedCorrectly = 37,
        Error_IPAMissingInfoPList = 38,
        Error_DeleteFile = 39,
        Error_DeleteDirectory = 40,
        Error_CreateDirectory = 41,
        Error_CopyFile = 42,
        Error_OnlyOneObbFileSupported = 50,
        Error_FailureGettingPackageInfo = 51,
        Error_OnlyOneTargetConfigurationSupported = 52,
        Error_ObbNotFound = 53,
        Error_AndroidBuildToolsPathNotFound = 54,
        Error_NoApkSuitableForArchitecture = 55,
        Error_FilesInstallFailed = 56,
        Error_RemoteCertificatesNotFound = 57,
        Error_LauncherFailed = 100,
        Error_UATLaunchFailure = 101,
        Error_FailedToDeleteStagingDirectory = 102,
        Error_MissingExecutable = 103,
        Error_DeviceNotSetupForDevelopment = 150,
        Error_DeviceOSNewerThanSDK = 151,
    Error_TestFailure = 152,
    Error_SymbolizedSONotFound = 153,
    Error_LicenseNotAccepted = 154,
    Error_AndroidOBBError = 155,
  };
  // ...
}

使用AssetRegistry检测资源是否存在

在Editor/UnrealEd/Private/FileHelpers.cpp中提供了一个实现，优先通过AssetRegistry来查找，查找不到则退回到从磁盘查找：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
namespace FileHelperPackageUtil
{
  /**
   * DoesPackageExist helper that rely on the AssetRegistry to validate if a package exists instead of hitting the FS
   * Fallback to the FS if the asset registry initial scan isn't done or we aren't in Editor
   */
  bool DoesPackageExist(UPackage* Package, FString* OutFilename = nullptr)
  {
    // Test using asset registry to figure out existence
    IAssetRegistry& AssetRegistry = FAssetRegistryModule::GetRegistry();
    if (!AssetRegistry.IsLoadingAssets() || !GIsEditor)
    {
      TArray<FAssetData> Data;
      FAssetRegistryModule::GetRegistry().GetAssetsByPackageName(Package->GetFName(), Data, true);

      if (Data.Num() > 0 && OutFilename)
      {
        *OutFilename = FPackageName::LongPackageNameToFilename(Package->GetName(), Package->ContainsMap() ? FPackageName::GetMapPackageExtension() : FPackageName::GetAssetPackageExtension());
      }

      return Data.Num() > 0;
    }
    return FPackageName::DoesPackageExist(Package->GetName(), nullptr, OutFilename);
  }
}

分析打包的资源

工程中有很多的资源其实并没有打到包中去，当需要分析包体中资源大小时，可以通过Asset Audit工具来实现，通过Window-Developer Tools-AssetAudit打开。

可以看到资源路径、大小、位于哪些Chunk中等一系列的信息，便于排查资源大小和Chunk中的资源冗余。

首先，需要说明Editor里的资源大小和最终打到包内的大小是不一样的，在右上角会列出已经打包的平台（Saved/Cooked）下的平台。

Asset Audit需要读取DevelopmentAssetRegistry.bin文件来得到某个平台的资源信息的，它在以下路径中：

1
Client\Saved\Cooked\WindowsNoEditor\FGame\Metadata\DevelopmentAssetRegistry.bin

这个文件记录着某个平台执行完Cook之后资源的大小信息，注意Cook之后的资源如Texture2D等设置的压缩均以执行，但是打包成pak也会执行压缩，这里列出来的大小是没有经过打包pak压缩的Cook资源之后的原始大小。

可以在打包时自动提取Cooked目录下的Metadata目录，在AssetAudit窗口的右上角选择Custom，选择DevelopmentAssetRegistry.bin文件即可。

UE4中ES3.1的75根骨骼限制

之前提到过在ES2.0上使用单个材质蒙皮的骨骼不能超过75根，在ES3之后就没有这个限制了，但是UE里目前还有这个限制。

Warning: SkeletalMesh SK_m0146b0003, is not supported for current feature level (ES3_1) and will not be rendered. NumBones 78 (supported 75), NumBoneInfluences: 4

Runtime/RHI/Public/RHIDefinitions.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
inline int32 GetFeatureLevelMaxNumberOfBones(const FStaticFeatureLevel FeatureLevel)
{
  switch (FeatureLevel)
  {
  case ERHIFeatureLevel::ES3_1:
    return 75;  
  case ERHIFeatureLevel::SM5:
    return 65536; // supports uint16
  default:
    checkf(0, TEXT("Unknown FeatureLevel %d"), (int32)FeatureLevel);
  }

  return 0;
}

看了下相关的代码，UE在下面这次提交中修改了ES3.1原本256到75，commit里提到的是修复了Mobile Preview的Crash:

Limit ES3.1 to 75 bones like ES2. All ES3.1 feature level platforms use UB for Bones. Project has to set Compat.MAX_GPUSKIN_BONES=75 to support SkelMeshes with more than 75 bones for ES3.1 and ES2.

该代码在4.21 Preview 4中提交：Unreal Engine 4.21 Preview

在answers上也有一些相关的问题：

upluginmanifest

项目打包时会根据项目启用的插件生成一个PROJECT_NAME.upluginmanifest文件，其中记录了每个启用的插件的uplugin的路径和内容信息，该文件也会打包到pak中。

Mount Point为：../../../PROJECT_NAME/Plugins/PROJECT_NAME.upluginmanifest

在Editor下运行时不会读取这个文件，通过扫描引擎和项目以及Mods目录下的Plugin目录来查找插件的，相关的逻辑在Runtime/Projects/Private/PluginManager.cpp的ReadAllPlugins函数中。

1
2
3
4
5
6
#if !WITH_EDITOR
  if (Project != nullptr)
  {
    FindPluginManifestsInDirectory(*FPaths::ProjectPluginsDir(), ManifestFileNames);
  }
#endif // !WITH_EDITOR

在非Editor下通过加载upluginmanifest文件来确定当前工程中有哪些插件的（upluginmanifest文件可以有多个，只要放在../../../PROJECT_NAME/Plugins目录下即可），如果一个插件在基础包中不存在，但是热更时新建了一个Content Only插件打包资源，需要把该插件添加至upluginmanifest中并且也需要把该插件的uplugin打包至pak中。

添加非Content路径的Non-Asset目录到基础包

在Project Settings-Packaging-Additional Non-Asset Directories to Package可以添加相对路Content下的目录，但是不能够直接选Content之外的目录。

但是，其实这里是可以填相对路径的，如添加[PROJECT_DIR]/Source/Script目录：

1
2
[/Script/UnrealEd.ProjectPackagingSettings]
+DirectoriesToAlwaysStageAsUFS=(Path="../Source/Script")

在打包时能够正确地处理这个相对路径的，Mount Point也正常：

1
"D:\UnrealProjects\Client\Source\Script\UnLua.lua" "../../../FGame/Source/Script/UnLua.lua"

使用这种相对路径可以实现把位于项目Content之外的Non-Asset目录添加到基础包中。

实现分析：
[/Script/UnrealEd.ProjectPackagingSettings]的DirectoriesToAlwaysStageAsUFS值是在Programs/AutomationTool/Scripts/CopyBuildToStagingDirectory.Automation.cs中被读取的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
private static void StageAdditionalDirectoriesFromConfig(DeploymentContext SC, DirectoryReference ProjectContentRoot, StagedDirectoryReference StageContentRoot, ConfigHierarchy PlatformGameConfig, bool bUFS, string ConfigKeyName)
{
    List<string> ExtraDirs;
    if (PlatformGameConfig.GetArray("/Script/UnrealEd.ProjectPackagingSettings", ConfigKeyName, out ExtraDirs))
    {
        // Each string has the format '(Path="TheDirToStage")'
        foreach (var PathStr in ExtraDirs)
        {
            string RelativePath = null;
            var PathParts = PathStr.Split('"');
            if (PathParts.Length == 3)
            {
                RelativePath = PathParts[1];
            }
            else if (PathParts.Length == 1)
            {
                RelativePath = PathParts[0];
            }
            if (RelativePath != null)
            {
                DirectoryReference InputDir = DirectoryReference.Combine(ProjectContentRoot, RelativePath);
                StagedDirectoryReference OutputDir = StagedDirectoryReference.Combine(StageContentRoot, RelativePath);
                if (bUFS)
                {
                    List<FileReference> Files = SC.FindFilesToStage(InputDir, StageFilesSearch.AllDirectories);
                    Files.RemoveAll(x => x.HasExtension(".uasset") || x.HasExtension(".umap") || (SC.DedicatedServer && x.HasExtension(".mp4")));
                    SC.StageFiles(StagedFileType.UFS, InputDir, Files, OutputDir);
                }
                else
                {
                    SC.StageFiles(StagedFileType.NonUFS, InputDir, StageFilesSearch.AllDirectories, OutputDir);
                }
            }
        }
    }
}

public static void CreateStagingManifest(ProjectParams Params, DeploymentContext SC)
{
    // ...
    // Stage any additional UFS and NonUFS paths specified in the project ini files; these dirs are relative to the game content directory
    if (PlatformGameConfig != null)
    {
        StageAdditionalDirectoriesFromConfig(SC, ProjectContentRoot, StageContentRoot, PlatformGameConfig, true, "DirectoriesToAlwaysStageAsUFS");
        // NonUFS files are never in pak files and should always be remapped
        StageAdditionalDirectoriesFromConfig(SC, ProjectContentRoot, StageContentRoot, PlatformGameConfig, false, "DirectoriesToAlwaysStageAsNonUFS");

        if (SC.DedicatedServer)
        {
            StageAdditionalDirectoriesFromConfig(SC, ProjectContentRoot, StageContentRoot, PlatformGameConfig, true, "DirectoriesToAlwaysStageAsUFSServer");
            // NonUFS files are never in pak files and should always be remapped
            StageAdditionalDirectoriesFromConfig(SC, ProjectContentRoot, StageContentRoot, PlatformGameConfig, false, "DirectoriesToAlwaysStageAsNonUFSServer");
        }
    }
    // ...
}

在Directory.Combine里正确地处理了我们所指定的相对于Content的../Source/Script路径。

FDataTime::UtcNow

注意FDataTime::UtcNow在同一帧的不同时机获取的到是不一样的，因为它底层调用的是GetSystemTime(Windows)。

uexp和ubulk的作用

Rather than one large asset, these allow us to write an asset’s bulk data (.ubulk) and exports (uexp) out into separate files. This system improves perf in certain circumstances where file read contiguity is lost due to the large size of assets. This feature avoids this by enabling the reader to skip over an asset’s bulk data when seeking to the next file in a series without having to actually have serialized and seeked past that data (since it’s in separate file).

为了优化性能把资源的信息和数据进行拆分，在进行资源信息的索引时不用访问真正的数据，提高了查找性能和内存消耗。

资源调试命令

可以在Console中使用以下命令：

1
obj list

会列出当前的资源加载信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
                          Class    Count      NumKB      MaxKB   ResExcKB  ResExcDedSysKB  ResExcShrSysKB  ResExcDedVidKB  ResExcShrVidKB     ResExcUnkKB
                          Class     4331   10240.85   12969.37       0.00            0.00            0.00            0.00            0.00            0.00
                       FontFace        9    9498.02    9498.02    9495.54         9495.54            0.00            0.00            0.00            0.00
                       MetaData      732    8441.93    8441.93       0.00            0.00            0.00            0.00            0.00            0.00
                   ScriptStruct     2165    3923.20    5156.56       0.00            0.00            0.00            0.00            0.00            0.00
                   SkeletalMesh        1    3988.86    3989.04    1974.06           30.55            0.00            0.00            0.00         1943.52
                       Function     7928    2012.63    2457.73       0.00            0.00            0.00            0.00            0.00            0.00
                        Package      732    1316.65    1453.87       0.00            0.00            0.00            0.00            0.00            0.00
                           Enum     1275     312.38     760.76       0.00            0.00            0.00            0.00            0.00            0.00
                  DeviceProfile       85     409.36     661.37       0.00            0.00            0.00            0.00            0.00            0.00
                       Material      103     418.41     467.83    4722.42         4722.42            0.00            0.00            0.00            0.00
                       ToolMenu       36     193.83     466.16       0.00            0.00            0.00            0.00            0.00            0.00
               DelegateFunction      652     165.51     185.93       0.00            0.00            0.00            0.00            0.00            0.00
                      Texture2D      146     111.05     111.05   56192.00            0.00            0.00        56192.00            0.00            0.00
     MaterialExpressionMultiply      194      66.84      98.67       0.00            0.00            0.00            0.00            0.00            0.00
                     StaticMesh       29      77.02      98.41    2055.31           23.56            0.00            0.00            0.00         2031.75
MaterialExpressionTextureSample       61      44.87      79.66       0.00            0.00            0.00            0.00            0.00            0.00
       MaterialExpressionCustom       68      59.53      70.68       0.00            0.00            0.00            0.00            0.00            0.00
        MaterialInstanceDynamic       32      53.74      65.76      16.45           16.45            0.00            0.00            0.00            0.00
                 GameNetworkMgr        1      64.43      64.43       0.00            0.00            0.00            0.00            0.00            0.00
                      BodySetup       41      42.91      62.30    1158.44         1158.44            0.00            0.00            0.00            0.00
     MaterialExpressionConstant      153      36.16      61.26       0.00            0.00            0.00            0.00            0.00            0.00

还有下列相关的命令：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Mem FromReport
obj list -alphasort
rhi.DumpMemory
LogOutStatLevels
ListSpawnedActors
DumpParticleMem
ConfigMem
r.DumpRenderTargetPoolMemory
ListTextures -alphasort
ListSounds -alphasort
ListParticleSystems -alphasort
obj list class=SoundWave -alphasort
obj list class=SkeletalMesh -alphasort
obj list class=StaticMesh -alphasort
obj list class=Level -alphasort

也可以使用memreport来进行详细的分析：

1
memreport -full

会在Saved/Profiling/MemReports下创建.memreport文件。

IOS基础包拆分

在前面提到了UE为Android提供了打包到obb中的文件过滤规则：

1
2
3
# Config/DefaultEngine.ini
[/Script/AndroidRuntimeSettings.AndroidRuntimeSettings]
+ObbFilters=-pakchunk1-*

但是UE并没有为IOS提供相应的操作，默认情况下会把IOS的所有的pak文件都打包至IPA中。

为了统一Android和IOS的基础包规则，我自己实现了IOS上类似Android那种指定过滤规则的功能，做个简单的介绍。

我使用的是Mac远程打包，流程是在Mac上编译代码生成IPA，拉回Win，在Win上进行Cook，生成Pak文件，最后把原始IPA解包，再添加Pak等文件组合成最终IPA。

我的需求是，自定义指定过滤规则，可以把某些文件忽略，不打包到IPA中。那么这一步的操作其实就位于把IPA解包再打包的流程里，经过翻阅UE的代码，发现这个操作是通过iPhonePackager这个独立程序来实现的，那么就需要对这个程序的代码进行改造了。

经过调试分析，发现真正实现重新打包IPA的操作是在以下函数中执行的：

Programs/IOS/iPhonePackager/CookTime.cs
1
2
3
4
/** 
* Using the stub IPA previously compiled on the Mac, create a new IPA with assets
*/
static public void RepackageIPAFromStub();

该函数位于iPhonePackager-CookTime类中。

1
2
3
4
5
6
7
8
9
10
11
12
static public void RepackageIPAFromStub()
{
  // ...
  string SourceDir = Path.GetFullPath(ZipSourceDir);
  string[] PayloadFiles = Directory.GetFiles(SourceDir, "*.*", Config.bIterate ? SearchOption.TopDirectoryOnly : SearchOption.AllDirectories);
  foreach (string Filename in PayloadFiles)
    {
       // read file to memory,add to ZipFileSystem
       // generate stub and ipa
    }
    //...
}

需要做的操作就是介入这个过程，把PayloadFiles中的文件列表通过我们自定义的规则来执行过滤。

从流程上分为以下几个步骤：

  1. 从项目中读取Filter的配置
  2. 创建出真正的过滤器
  3. 在RepackageIPAFromStub遍历文件的流程里使用过滤器进行检测是否需要被打入ipa

只需要几十行代码就可以实现，首先需要添加一个IniReader的类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
using Tools.DotNETCommon;
using System.Runtime.InteropServices;
using Ini;

namespace Ini
{
  public class IniReader
  {
    private string path;

    [DllImport("kernel32")]
    private static extern int GetPrivateProfileString(string section, string key, string def,
      StringBuilder retVal, int size, string filePath);

    public IniReader(string INIPath)
    {
      path = INIPath;
    }

    public string ReadValue(string Section, string Key)
    {
      StringBuilder ReaderBuffer = new StringBuilder(255);
      int ret = GetPrivateProfileString(Section, Key, "", ReaderBuffer, 255, this.path);
      return ReaderBuffer.ToString();
    }
  }
}

然后在RepackageIPAFromStub函数中创建过滤器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
FileFilter IpaPakFileFilter = new FileFilter(FileFilterType.Include);
{
  string ProjectDir = Directory.GetParent(Path.GetFullPath(Config.ProjectFile)).FullName;
  // Program.Log("ProjectDir path {0}", ProjectDir);
  string EngineIni = Path.Combine(ProjectDir,"Config","DefaultEngine.ini");
  // Program.Log("EngineIni path {0}", EngineIni);
  IniReader EngineIniReader = new IniReader(EngineIni);
  // string RawPakFilterRules = EngineIniReader.ReadValue("/Script/IOSRuntimeSettings.IOSRuntimeSettings", "IPAFilters");
  Program.Log("RawPakFilterRules {0}", RawPakFilterRules);
  string[] PakRules = RawPakFilterRules.Split(',');   
  // foreach(string Rule in PakRules) {Program.Log("PakRules {0}", Rule);}
  
  List<string> PakFilters = new List<string>(PakRules);
  if (PakFilters != null)
  {
    IpaPakFileFilter.AddRules(PakFilters);
  }
}

这里从项目的Config/DefaultEngine.ini的[/Script/IOSRuntimeSettings.IOSRuntimeSettings]项读取IPAFilters的值，规则与Android相同，但是要把规则都写在一行，多个规则以逗号分隔。

1
2
[/Script/IOSRuntimeSettings.IOSRuntimeSettings]
IPAFilters=-*.pak,pakchunk0-*

最终，还需要在RepackageIPAFromStub遍历Payload文件的循环中进行检测是否匹配我们指定的过滤规则：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
static public void RepackageIPAFromStub()
{
  // ...
  string SourceDir = Path.GetFullPath(ZipSourceDir);
  string[] PayloadFiles = Directory.GetFiles(SourceDir, "*.*", Config.bIterate ? SearchOption.TopDirectoryOnly : SearchOption.AllDirectories);
  foreach (string Filename in PayloadFiles)
  {
    if (!IpaPakFileFilter.Matches(Filename))
    {
      Program.Log("IpaPakFileFilter not match file {0}", Filename);
      continue;
    }
    // Program.Log("IpaPakFileFilter  match file {0}", Filename);
  }
  //...
}

这样再执行打包IOS，就会按照指定的过滤规则来添加文件了，实现了与Android上一致的行为。

打包过程中的Log如下（上文代码已注释）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Saving IPA ...
ProjectDir path C:\BuildAgent\workspace\PackageWindows\Client
EngineIni path C:\BuildAgent\workspace\PackageWindows\Client\Config\DefaultEngine.ini
RawPakFilterRules -*.pak,pakchunk0-*
PakRules -*.pak
PakRules pakchunk0-*
IpaPakFileFilter match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\Assets.car
IpaPakFileFilter match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\Info.plist
IpaPakFileFilter match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\LaunchScreenIOS.webp
IpaPakFileFilter match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\Manifest_DebugFiles_IOS.txt
IpaPakFileFilter match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\Manifest_NonUFSFiles_IOS.txt
IpaPakFileFilter match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\mute.caf
IpaPakFileFilter match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\ue4commandline.txt
IpaPakFileFilter match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\cookeddata\fgame\content\movies\logo.mp4
IpaPakFileFilter match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\cookeddata\fgame\content\movies\sparkmore.mp4
IpaPakFileFilter match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\cookeddata\fgame\content\paks\pakchunk0-ios.pak
IpaPakFileFilter not match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\cookeddata\fgame\content\paks\pakchunk1-ios.pak
IpaPakFileFilter not match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\cookeddata\fgame\content\paks\pakchunk2-ios.pak
IpaPakFileFilter match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\Engine\Content\SlateDebug\Fonts\LastResort.ttf
IpaPakFileFilter match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\GCloudVoice.bundle\files\config.json
IpaPakFileFilter match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\GCloudVoice.bundle\files\libwxvoiceembed.bin
IpaPakFileFilter match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\GCloudVoice.bundle\files\mute_detection.aiff
IpaPakFileFilter match file C:\BuildAgent\workspace\PackageWindows\Client\Saved\StagedBuilds\IOS\GRobotResource.bundle\config.json
...

可以看到，过滤规则已经生效了。

Android基础包拆分

在打包时，不想要把所有的资源都打包到apk中，所以可以在打包时进行拆分，只把必要资源打包到apk中，首先需要把基础包中的资源进行pak拆分，可以把通过Project Settings-Asset Manager中进行设置或者通过创建PrimaryAssetLable资源进行标记。

目标是：

  1. 把基础包的打包资源拆分到多个Pak中
  2. 只把必要的pak文件打包到apk里
  3. 其余的pak在运行时进行下载

第一步都可以通过项目设置进行控制，第二部的条件就是要实现一个过滤规则，不过UE已经提供了这个机制，可以指定过滤掉哪些文件，只需要添加配置即可。

1
2
3
4
5
# Config/DefaultEngine.ini
[/Script/AndroidRuntimeSettings.AndroidRuntimeSettings]
+ObbFilters=-pakchunk1-*
+ObbFilters=-pakchunk2-*
+ObbFilters=-pakchunk3-*

ObbFilters的规则以-开头就是排除规则，会把基础包中的chunk1-3的pak给过滤掉，可以用于后续的下载流程。

也可以指定Exclute和Include规则组合来用：

1
2
+ObbFilters=-*.pak
+ObbFilters=pakchunk0-*

第一步忽略掉所有的pak文件，然后把pakchunk0-*.pak显式添加至obb中。

UMG OnTouchStarted不触发

注意不要使用UButton来作为触发控件来接收OnTouchStarted的事件，使用Board或者Image都可以，但是UButton不行，估计是UButton拦截了事件。

监听资源操作事件

可以通过IAssetRegistry获取到下列事件的delegate并监听：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FAssetAddedEvent, FAssetAddedEvent);
virtual FAssetAddedEvent& OnAssetAdded() override { return AssetAddedEvent; }

DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FAssetRemovedEvent, FAssetRemovedEvent);
virtual FAssetRemovedEvent& OnAssetRemoved() override { return AssetRemovedEvent; }

DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FAssetRenamedEvent, FAssetRenamedEvent);
virtual FAssetRenamedEvent& OnAssetRenamed() override { return AssetRenamedEvent; }

DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FAssetUpdatedEvent, FAssetUpdatedEvent );
virtual FAssetUpdatedEvent& OnAssetUpdated() override { return AssetUpdatedEvent; }

DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FInMemoryAssetCreatedEvent, FInMemoryAssetCreatedEvent );
virtual FInMemoryAssetCreatedEvent& OnInMemoryAssetCreated() override { return InMemoryAssetCreatedEvent; }

DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FInMemoryAssetDeletedEvent, FInMemoryAssetDeletedEvent );
virtual FInMemoryAssetDeletedEvent& OnInMemoryAssetDeleted() override { return InMemoryAssetDeletedEvent; }

DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FFilesLoadedEvent, FFilesLoadedEvent );
virtual FFilesLoadedEvent& OnFilesLoaded() override { return FileLoadedEvent; }

DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FFileLoadProgressUpdatedEvent, FFileLoadProgressUpdatedEvent );
virtual FFileLoadProgressUpdatedEvent& OnFileLoadProgressUpdated() override { return FileLoadProgressUpdatedEvent; }

Android not found uproject

UE中有一个BUG，在4.25.1引擎版本中可以复现，步骤如下：

  1. 安装apk，第一次启动游戏
  2. 打开UE的沙盒数据目录UE4Game/PROJECTNAME，在这个目录下创建Content/Paks目录
  3. 重新启动游戏

Log中也有Project file not found: ../../../FGame/FGame.uproject提示。

在Android上自动挂载的Pak文件可以放到Saved/Paks下，有时间具体分析一下这个问题。

提取chunk的paklist文件

在开启Generate Chunks之后，如果项目中有添加PrimaryAssetLable资源，会生成对应的Chunk文件。
生成的paklist文件所在目录为：

1
2
3
4
5
6
# 源码版
Engine\Programs\AutomationTool\Saved\Logs
# 安装版
C:\Users\lipengzha\AppData\Roaming\Unreal Engine\AutomationTool\Logs\C+Program+Files+Epic+Games+UE_4.26
# 安装版 BuildCookRun
C:\Users\lipengzha\AppData\Roaming\Unreal Engine\AutomationTool\Logs\C+Program+Files+Epic+Games+UE_4.26\BuildCookRun

paklist相关的文件列表如下：

1
2
3
4
5
6
PakList_pakchunk0-WindowsNoEditor.txt
PakList_pakchunk1-WindowsNoEditor.txt
PakList_pakchunk2-WindowsNoEditor.txt
PrePak_WindowsNoEditor_NonUFSFiles.txt
PrePak_WindowsNoEditor_NonUFSFilesDebug.txt
PrePak_WindowsNoEditor_UFSFiles.txt

需要重点关注的是PakList_pakchunk*.txt和PrePak*_UFSFiles.txt这几个文件，NonUFSFiles.txt中的文件不会被打包到Pak中。
PakList_pakchunk*.txt中是每一个chunk中包含的文件，并且是以绝对路径 Mount路径的方式来组织的，PrePak*_UFSFiles.txt是当前打包的版本中所有包含的文件，但其中的路径不是绝对路径 Mount路径。

在项目设置中添加的NoUFS文件夹都会默认打包到chunk0的pak中。

在Windows上可以使用以下命令来自动拷贝：

1
echo f|xcopy /y/i/s/e "%AppData%\Unreal Engine\AutomationTool\Logs\E+UnrealEngine+Launcher+UE_4.25\PakList_*.txt" "E:\ClientVersion\0.0.1.0"

IOS远程构建最大文件不能超过2G

Win上远程构建出IOS包的流程是代码和bundle都上传到Mac上编译，生成不包含资源的IPA，拉回本地执行资源Cook生成Pak后，把代码的IPA和资源的Pak合并成真正的IPA文件。
但是这样有个问题，UE里的实现是把所有要合并的文件读到内存中再合并打包的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
static public void RepackageIPAFromStub()
{
   // ...
  // Add all of the payload files, replacing existing files in the stub IPA if necessary (should only occur for icons)
  {
    string SourceDir = Path.GetFullPath(ZipSourceDir);
    string[] PayloadFiles = Directory.GetFiles(SourceDir, "*.*", Config.bIterate ? SearchOption.TopDirectoryOnly : SearchOption.AllDirectories);

    foreach (string Filename in PayloadFiles)
    {
      // Get the relative path to the file (this implementation only works because we know the files are all
      // deeper than the base dir, since they were generated from a search)
      string AbsoluteFilename = Path.GetFullPath(Filename);
      string RelativeFilename = AbsoluteFilename.Substring(SourceDir.Length + 1).Replace('\\', '/');

      string ZipAbsolutePath = String.Format("Payload/{0}{1}.app/{2}",
        Config.GetTargetName(),
        Program.Architecture,
        RelativeFilename);

      byte[] FileContents = File.ReadAllBytes(AbsoluteFilename);
      if (FileContents.Length == 0)
      {
        // Zero-length files added by Ionic cause installation/upgrade to fail on device with error 0xE8000050
        // We store a single byte in the files as a workaround for now
        FileContents = new byte[1];
        FileContents[0] = 0;
      }

      FileSystem.WriteAllBytes(RelativeFilename, FileContents);

      if ((FileContents.Length >= 1024 * 1024) || (Config.bVerbose))
      {
        FilesBeingModifiedToPrintOut.Add(ZipAbsolutePath);
      }
    }
  }
  // ...
}

可以看到是把Payload的每个文件读到byte[]里的，这就有了一个限制，在C#中，数组的长度最大是int32.MaxValue，意味着byte[]不能存储超过2G的文件，不然就会触发异常。
查询了MSDN的文档，发现设置gcAllowVeryLargeObjects也不会改变单个维度的数组的大小。

所以这个问题只能从其他方面入手了，让UE进行资源打包的时候把Pak的文件拆分，让每个文件都小于2GB即可，可以通过UE里的Chunk机制进行拆分。

DS产生corefile

在Shipping的时候DS Crash可以通过启动参数-core来指定可以生成core文件。

指定SkeletalMesh的LOD级别

可以直接对设置ForcedLodModel的值（LOD0需要设置1，实际的LOD级别就是N-1，值为0则是自动）：

也可以对USkinnedMeshComponent实例调用SetForcedLOD函数：

Runtime/Engine/Classes/Components/SkinnedMeshComponent.h
1
2
3
4
// Get ForcedLodModel of the mesh component. Note that the actual forced LOD level is the return value minus one and zero means no forced LOD 
int32 USkinnedMeshComponent::GetForcedLOD() const 
// Set new ForcedLODModel that forces to set the incoming LOD. Range from [1, Max Number of LOD]. This will affect in the next tick update. 
void USkinnedMeshComponent::SetForcedLOD(int32 InNewForcedLOD)

可以用在背包中显示3D模型的场景，避免使用比较低的LOD级别。

HotPatcher的自动化导出Release脚本

组合命令使用HotPatcher的Commandlet，实现Release信息的自动化导出：

HotRelease.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
import os 
import sys  
import argparse 
parser = argparse.ArgumentParser(description="used for build engine or project")  
hot_release = parser.add_argument_group('HotRelease') 
# project 
hot_release.add_argument('--enginebin',help='UE4Editor-cmd.exe binary path')  
hot_release.add_argument('--projectdir',help='project root directory')  
hot_release.add_argument('--projectname',help='project name,match projectname.uproject')  
hot_release.add_argument('--versiondir',help='client version file dir') 
hot_release.add_argument('--versionid',help='current release version id') 
hot_release.add_argument('--outdir',help='export release result save dir')  
platform_list=[ 
    "WindowsNoEditor",  
    "Android_ASTC", 
    "IOS",  
] 
def getPlatformPakListName(PlatformName,ProjectName): 
    return "PakList_%s-%s.txt" % (ProjectName,PlatformName) 
def getProjectFullPath(ProjectDir,ProjectName): 
    return "%s\\%s.uproject" % (ProjectDir,ProjectName) 
def get_platform_paklist(clientversion_path,versionid,project_name):  
    result_dict = {}  
    if os.path.exists(clientversion_path):  
        version_paklist_path = os.path.normpath(os.path.abspath(os.path.join(clientversion_path, versionid))) 
        print("versionid: %s" % versionid)  
        for platform in platform_list:  
            platform_paklist_path = os.path.join(version_paklist_path, getPlatformPakListName(platform,project_name)) 
            if os.path.exists(platform_paklist_path): 
                result_dict[platform] = platform_paklist_path 
                print("platform:%s paklist:%s" % (platform,result_dict[platform]))  
    return result_dict  
def ExportRelease(versionid,engine_bin_path,project_dir,project_name,platform_paklist_dict,savepath): 
    AddPlatformPakListCmd = "-AddPlatformPakList="  
    for key,value in platform_paklist_dict.items(): 
        AddPlatformPakListCmd = "%s%s+%s," % (AddPlatformPakListCmd,key,value)  
    print(AddPlatformPakListCmd)  
    commands_tuple = [  
        engine_bin_path,  
        getProjectFullPath(project_dir,project_name), 
        "-run=HotRelease",  
        "-versionid=%s" % (versionid),  
        "-byPakList=true",  
        AddPlatformPakListCmd,  
        "-savepath.path=%s" % (savepath), 
        # "-wait" 
    ] 
    final_cmd = ""  
    for param in commands_tuple:  
        final_cmd = "%s %s" % (final_cmd,param) 
    print(final_cmd)  
    os.system(final_cmd)  
def GetArgByName(ParserArgs,ArgName): 
    ArgsPairs = ParserArgs.__dict__ 
    for key,value in ArgsPairs.items(): 
        if key == ArgName:  
            return value  
def printSelectorHelp():  
    print("Args is invalid!") 
def main(): 
    ParserArgs = parser.parse_args()  
    engine_bin_path = GetArgByName(ParserArgs,"enginebin")  
    project_dir = GetArgByName(ParserArgs,"projectdir") 
    project_name = GetArgByName(ParserArgs,"projectname") 
    version_id = GetArgByName(ParserArgs,"versionid") 
    clientversion_path = GetArgByName(ParserArgs,"versiondir")  
    outdir = GetArgByName(ParserArgs,"outdir")  
    if engine_bin_path and project_dir and project_name and version_id and clientversion_path and outdir: 
        ExportRelease(  
            version_id, 
            engine_bin_path,  
            project_dir,  
            project_name, 
            get_platform_paklist(clientversion_path,version_id,project_name), 
            outdir  
            ) 
    else: 
        printSelectorHelp() 
if __name__ == "__main__":  
   main()

Texture的压缩

之前的笔记中，提到过可以在Project Settings-Cooker-Texture-ASTC Compression vs Size可以设置默认的资源质量和大小的级别： 

1
2
3
4
5
0=12x12 
1=10x10 
2=8x8 
3=6x6 
4=4x4

在Texture的资源编辑中也可以针对某个Texture单独设置：

Lowest->Hightest对应着0-4的值，使用Default则使用项目设置中的配置。

并且，设置Compression Settings的类型也会对资源压缩的类型有差别，Default则是项目设置中的参数，如果设置成NormalMap的类型会是ASTC_4x4的。

listtextures

控制台命令listtextures可以列出已被加载过的Texture的信息。

Unreal Insights实时分析Android

上一节提到了使用SessionFrontEnd实时分析Android的方法，在实际的测试当中发现不太稳定，会造成游戏的Crash，UE在新的引擎版本中也提供了新的性能分析工具Unreal Insights，可以更方便和直观地进行Profile。
文档：

同样也需要端口映射，需要把PC的1980端口映射到设备上： 

1
adb reverse tcp:1980 tcp:1980

然后需要给Android设备添加启动命令： 

1
../../../FGame/FGame.uproject -Messaging -SessionOwner="lipengzha" -SessionName="Launch On Android Device" -iterative -tracehost=127.0.0.1 -Trace=CPU

在PC上开启Unreal Insights，在手机上启动游戏，即可实时捕获：

Unreal Insights也可以实时捕获PIE的数据，需要在Editor启动时添加-trace参数：

1
UE4Editor.exe PROJECT_NAME.uproject -trace=counters,cpu,frame,bookmark,gpu

在启动游戏后在Unreal Insights里通过New Connection监听127.0.0.1即可。

SessionFrontEnd实时Profile Android

有几个条件：

  1. 需要USB连接PC和手机
  2. 需要安装adb

首先需要映射端口，因为SessionFrontEnd是通过监听端口的方式来与游戏内通信的，手机和PC并不在同一个网段，所以需要以adb的形式把PC的监听端口转发给手机的端口。

SessionFrontEnd的监听端口可以通过对UE4Editor.exe的端口分析获取： 

1
2
3
4
5
6
7
8
9
C:\Users\lipengzha>netstat -ano | findstr "231096"  
  TCP    0.0.0.0:1985           0.0.0.0:0              LISTENING       231096 
  TCP    0.0.0.0:3961           0.0.0.0:0              LISTENING       231096 
  TCP    0.0.0.0:3963           0.0.0.0:0              LISTENING       231096 
  TCP    127.0.0.1:4014         127.0.0.1:12639        ESTABLISHED     231096 
  TCP    127.0.0.1:4199         127.0.0.1:12639        ESTABLISHED     231096 
  UDP    0.0.0.0:6666           *:*                                    231096 
  UDP    0.0.0.0:24024          *:*                                    231096 
  UDP    0.0.0.0:58101          *:*                                    231096

需要把PC的1985端口映射到Android的1985端口，这样手机上APP启动时，连接0.0.0.0的1985端口就可以连接到PC上的端口。

通过adb命令来执行： 

1
adb reverse tcp:1985 tcp:1985

然后需要给手机上App指定启动参数： 

1
../../../FGame/FGame.uproject -Messaging -SessionOwner="lipengzha" -SessionName="Launch On Android Device"

把这些文本保存为UE4Commandline.txt文件，放到项目的数据目录下即可，具体路径为： 

1
/sdcard/UE4Game/PROJECT_NAME/

之后直接启动App，在PC上的SessionFrontEnd中就可以看到设备的数据了。

C++中获取引擎的版本信息

可以通过FEngineVersion来获取：

Runtime/Core/Public/Misc/EngineVersion.h
1
2
/** Gets the current engine version */  
static const FEngineVersion& Current();

判断对象是否有效的方式与区别

在UE中的UObject对象实例传递和存储都是以UObject*的指针来存储的，因为指针只是一块内存的地址，而这块内存是否是有效的对象是不清楚的。所以需要有不同检测方式来检测，一般情况下有以下几种状态：

  1. 指针为NULL/nullptr
  2. 指针非NULL，对象被GC标记为PaddingKill
  3. 一块无效的内存地址

如果指针地址是一个无效的内存地址，那么不能通过它来调用任何获取/修改到任何数据成员的函数的。如果对无效的内存地址调用IsPaddingKill的，会Crash，所以要从更底层的角度来检测。

这三种状态可以通过以下几种检测方式来判断： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 检测指针是否为Null，对象是否被注册(UClass是否存在)  
/** 
* Checks to see if the object appears to be valid 
* @return true if this appears to be a valid object 
*/  
bool IsValidLowLevel() const; 
// 从内存布局上检测对象是否有效，并会检测对象的CDO/UClass是否存在 
// 可以用于加载资源的检测  
/** 
* Faster version of IsValidLowLevel.  
* Checks to see if the object appears to be valid by checking pointers and their alignment. 
* Name and InternalIndex checks are less accurate than IsValidLowLevel. 
* @param bRecursive true if the Class pointer should be checked with IsValidLowLevelFast  
* @return true if this appears to be a valid object 
*/  
bool IsValidLowLevelFast(bool bRecursive = true) const; 
// 检测指针是否为null，以及是否被GC清理，如果指针是无效的内存地址会Crash 
/** 
* Test validity of object 
* 
* @param  Test      The object to test  
* @return Return true if the object is usable: non-null and not pending kill  
*/  
FORCEINLINE bool IsValid(const UObject *Test) 
{ 
  return Test && !Test->IsPendingKill();  
}

M1 Mac的UE4.26兼容性报告

UMG CanvasPanel合批

在Project Settings-Engine-Slate Settings中开启Explicit Canvas Child ZOrder可以开启Canvas的合并。

蓝图节点右上角标识的含义

OptimizeCode代码优化

注意：如果关闭代码优化导致构造对象Crash（或者new走不到对象的构造函数），需要检查项目和插件的代码中是否有重名的类，会导致一些奇怪的问题。
在build.cs中可以通过OptimizeCode来控制是否执行代码优化： 

1
OptimizeCode = CodeOptimization.InShippingBuildsOnly;

有以下几个可选值： 

1
2
3
4
5
6
7
8
public enum CodeOptimization  
{ 
  Never,  
  InNonDebugBuilds, 
  InShippingBuildsOnly, 
  Always, 
  Default,  
}

当开启优化时，对翻译单元的编译指令参数： 

1
2
3
4
/Ox 
/Ot 
/GF 
/Zo

并且会使用优化版本的Engine/SharedPCH.Engine.h。

当关闭优化时的编译指令为： 

1
/Od

会使用非优化版本的Engine/SharedPCH.Engine.NonOptimized.h.

ASTC Compression Quality By Size

在项目的DefaultEngine.ini中的[/Script/UnrealEd.CookerSettings]中通过DefaultASTCQualityBySize设置（0-4）： 

1
2
3
[/Script/UnrealEd.CookerSettings] 
DefaultASTCQualityBySize=2  
DefaultASTCQualityBySpeed=3

0-4分别对应以下压缩级别： 

1
2
3
4
5
0=12x12 
1=10x10 
2=8x8 
3=6x6 
4=4x4

引擎修改语言的配置存储

在UE引擎中的的编辑器偏好设置中修改区域和语言，会被存储在以下文件中： 

1
C:\Users\lipengzha\AppData\Local\UnrealEngine\4.25\Saved\Config\Windows\EditorSettings.ini

其值如下： 

1
2
3
4
[Internationalization]  
Language=zh-Hans  
Culture=  
Locale=zh-Hans

如果是英文的，则是en.

中文赋值给FString

首先，把文件编码修改为UTF8，然后使用以下方式： 

1
FString str = UTF8_TO_TCHAR("中文");

注意对UTF8编码的中文不要使用TEXT，因为文件编码UTF8已经是把中文字符串编码成了UTF8的方式，所以可以直接使用""来包裹中文字符，如果此时使用TEXT作为宽字符存储UTF8的编码，在UTF8_TO_TCHAR中会出现错误。

IOS相对到绝对路径转换

在接入的一些库中，需要传递文件的绝对路径，可以通过下面的方式进行转换： 

1
IFileManager::Get().ConvertToAbsolutePathForExternalAppForRead(*InRelatePath);;

它是定义在IFileManager接口中的一个虚函数，应该在各个平台的PlatformFile中均有自己的实现，但是在Android中依然是相对路径的，不知道UE是不是忘了实现了。

IOS：Runtime/Core/Public/IOS/IOSPlatformFile.h

Android上相对路径转换成绝对路径的方式在之前的笔记中有写。

Android相对路径转绝对路径

有些需求需要把FPaths::ProjectDir()等路径转换为移动设备上的绝对路径，可以参考Core/Private/Android/AndroidPlatformFile.cpp#L126中的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Constructs the base path for any files which are not in OBB/pak data
const FString &GetFileBasePath()
{
  static FString BasePath = GFilePathBase + FString(FILEBASE_DIRECTORY) + FApp::GetProjectName() + FString("/");
  return BasePath;
}


FString AndroidRelativeToAbsolutePath(bool bUseInternalBasePath, FString RelPath)
{
  if (RelPath.StartsWith(TEXT("../"), ESearchCase::CaseSensitive))
  {
    
    do {
      RelPath.RightChopInline(3, false);
    } while (RelPath.StartsWith(TEXT("../"), ESearchCase::CaseSensitive));

    return (bUseInternalBasePath ? GInternalFilePath : GetFileBasePath()) / RelPath;
  }
  return RelPath;
}

强引用UClass

如果在UPROPERTY中通过TSubclassOf引用了一个UClass，会导致该UClass的BP的CDO无法被释放：

1
2
URPOPERTY()
TSubclassOf<class UClassName> StrongClassRef;

可以使用软引用的方式来解决：

1
2
URPOPERTY()
TSoftClassPtr<class UClassName> StrongClassRef;

TSoftClassPtr is a templatized wrapper around FSoftObjectPtr that works like a TSubclassOf, it can be used in UProperties for blueprint subclasses

UE4编译代码的真正命令参数

在之前的文章Build flow of the Unreal Engine4 project中有提到，UE编译模块的时候会执行到ExecuteActions中。
那么UE真正编译每个翻译单元的编译器参数是什么呢？
在UBT调用ExecuteAction之前，会完成所有编译参数的拼接和预处理。

1
static void ExecuteAction(ManagedProcessGroup ProcessGroup, BuildAction Action, List CompletedActions, AutoResetEvent CompletedEvent)

在Win上是通过调用cl-filter.exe来执行的，而如何把代码和编译参数喂给编译器呢？
UE是通过生成了一个.cpp.obj.response来记录当前编译单元的信息的，包含编译器参数和包含目录/输出等等。

该文件在生成位置在模块的Intermediate目录下：

1
Intermediate\Build\Win64\UE4Editor\Development\HotPatcherRuntime\FlibPakReader.cpp.obj.response

文件内容太长，可以下载该文件查看：FlibPakReader.cpp.obj.response

可以使用手动调用cl.exe的方式来执行测试：

1
2
cl.exe @CPP_OBJ_RESPONSE_PATH //showIncludes
// "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Tools\MSVC\14.27.29110\bin\HostX64\x64\cl.exe"  @"C:\BuildAgent\workspace\PackageWindows\Client\Plugins\UnLua\Intermediate\Build\Win64\UE4\Development\LuaProtobuf\Module.LuaProtobuf.cpp.obj.response" /showIncludes

build.cs添加宏定义的值

在UE中使用build.cs添加宏定义：

1
2
PrivateDefinitions.Add("TEST_MACRO_HAS_VALUE=1");
PublicDefinitions.Add("TEST_MACRO_NOT_VALUE");

可以指定值，也可以不指定宏的值，但是UE生成时会给没有值的宏为1：

1
#define TEST_MACRO_NOT_VALUE 1

可以在UE生成的Deginitions.MODULENAME.h中查看，位于以下位置：

1
Intermediate\Build\PLATFIRM_NAME\UE4\Development\MODULE_NAME\Definitions.MODULE_NAME.h

编译引擎的命令

与BuildGraph的方式不同，直接在VS中点UE4编译所使用的命令行：

1
Engine/Build/BatchFiles/Build.bat -Target="UE4Editor Win64 Development" -Target="ShaderCompileWorker Win64 Development -Quiet" -WaitMutex -FromMsBuild

编辑器检测Actor移动

可以通过重写Editor中的PostEditMove函数：

1
virtual void PostEditMove(bool bFinished) override;

Actor Tick in Editor

在Actor的构造函数中开启Tick：

1
PrimaryActorTick.bCanEverTick = true;

但是这个只能设置Runtime的Actor的Tick，当想要让Editor下的Actor也能执行Tick，则需要重写Actor的ShouldTickIfViewportsOnly函数：

1
2
3
4
5
6
7
8
// .h
virtual bool ShouldTickIfViewportsOnly()const override;

// .cpp
bool ARecastDetourTestingActor::ShouldTickIfViewportsOnly() const
{
  return true;
}

在AActor的类中，默认返回false.

UE4 ERROR: Missing object file

在编译时遇到以下错误：

1
2
3
ERROR: Missing object file C:\BuildAgent\workspace\PackageWindows\InstalledEngine\Engine\Engine\Plugins\Runtime\Database\SQLiteCore\Intermediate\Build\Android\UE4\Developmen
t\SQLiteCore\codec.ca7.o listed in C:\BuildAgent\workspace\PackageWindows\InstalledEngine\Engine\Engine\Plugins\Runtime\Database\SQLiteCore\Intermediate\Build\Android\UE4\Develo
pment\SQLiteCore\SQLiteCore.precompiled

在引擎中添加了代码，并且编译了Android的的平台支持（通过Make Installed Win64），但是在编译IOS时出现这样的报错。
经过排查发现，这个错误时找不到codec.ca7.o文件导致的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 
public override List<FileItem> Compile(ReadOnlyTargetRules Target, UEToolChain ToolChain, CppCompileEnvironment BinaryCompileEnvironment, FileReference SingleFileToCompile, ISourceFileWorkingSet WorkingSet, IActionGraphBuilder Graph)
{
  //UEBuildPlatform BuildPlatform = UEBuildPlatform.GetBuildPlatform(BinaryCompileEnvironment.Platform);

  List<FileItem> LinkInputFiles = base.Compile(Target, ToolChain, BinaryCompileEnvironment, SingleFileToCompile, WorkingSet, Graph);

  CppCompileEnvironment ModuleCompileEnvironment = CreateModuleCompileEnvironment(Target, BinaryCompileEnvironment);

  // If the module is precompiled, read the object files from the manifest
  if(Rules.bUsePrecompiled && Target.LinkType == TargetLinkType.Monolithic)
  {
    if(!FileReference.Exists(PrecompiledManifestLocation))
    {
      throw new BuildException("Missing precompiled manifest for '{0}'. This module was most likely not flagged for being included in a precompiled build - set 'PrecompileForTargets = PrecompileTargetsType.Any;' in {0}.build.cs to override.", Name);
    }

    PrecompiledManifest Manifest = PrecompiledManifest.Read(PrecompiledManifestLocation);
    foreach(FileReference OutputFile in Manifest.OutputFiles)
    {
      FileItem ObjectFile = FileItem.GetItemByFileReference(OutputFile);
      if(!ObjectFile.Exists)
      {
        throw new BuildException("Missing object file {0} listed in {1}", OutputFile, PrecompiledManifestLocation);
      }
      LinkInputFiles.Add(ObjectFile);
    }
    return LinkInputFiles;
  }
  // ...
}

去插件的Intermediate中查看了一下，确实没有这个文件，估计是拷贝造成的问题。

分隔String为数组

可以使用FString的ParserIntoArray函数：

1
2
TArray<FString> BreakedPoints;
UFlibAppHelper::GetSourceVersion().ParseIntoArray(BreakedPoints,TEXT("."));

UE4.25中ShaderPatch问题

在4.25引擎版本中调用FShaderCodeLibrary::CreatePatchLibrary来创建ShaderCode Patch会触发check抛异常：

这是因为FEditorShaderCodeArchive的构造函数中调用了ShaderHashTable的Initialize，并给了默认值0x1000：

1
2
3
4
5
6
7
8
9
10
FEditorShaderCodeArchive(FName InFormat)
    : FormatName(InFormat)
    , Format(nullptr)
{
  Format = GetTargetPlatformManagerRef().FindShaderFormat(InFormat);
  check(Format);

  SerializedShaders.ShaderHashTable.Initialize(0x10000);
  SerializedShaders.ShaderMapHashTable.Initialize(0x10000);
}

导致在后续的流程中(FSerializedShaderArchive::Serialize)调用Initialize的时候check失败了(因为HaseSize已经有值了，并不是0，对其再调用Initialize就触发了check)：

查了下FEditorShaderCodeArchive构造函数中调用Initialize的代码是在4.25之后的引擎版本才有的，所以影响到的之后4.25+的版本。
代码对比：

解决方案：把FSerializedShaderArchive::Serialize中ShaderMapHashTable的Initialize和ShaderHashTable的Initialize在Editor下注释掉，因为FEditorShaderCodeArchive的代码只在Editor下有效，并且是只在生成ShaderPatch时有用。

这就造成了以下几个问题：

  1. FEditorShaderCodeArchive的构造只有Eidotor并且ShaderPatch是才有用，也就意味着这里写的ShaderMapHashTable的Initialize和ShaderHashTable的Initialize只有在创建ShaderPatch时才会执行
  2. 在打基础包时执行Cook会编译shader，但是不会执行FEditorShaderCodeArchive的构造，ShaderMapHashTable的Initialize和ShaderHashTable的Initialize也就不会执行，就需要在使用的地方来调用它们的初始化

这也是UE中没有管理好这两个状态的地方：在FEditorShaderCodeArchive和FSerializedShaderArchive::Serialize中都做了Initialize的操作，在打基础包时造成了ShaderMapHashTable和ShaderHashTable的Initialize已经被FEditorShaderCodeArchive初始化的情况下又被FSerializedShaderArchive::Serialize执行了一遍，导致Crash，但是我们又不能粗暴地把任何一处的初始化操作去掉，只能通过检测ShaderMapHashTable和ShaderHashTable的Initialize是否已经被执行，来选择性的跳过。

阅读代码可以知道ShaderMapHashTable和ShaderHashTable的Initialize只应该执行一次，并且初始化之后HashSize和IndexSize应该具有非0值：

Runtime/Core/Public/Containers/HashTable.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
FORCEINLINE void FHashTable::Initialize(uint32 InHashSize, uint32 InIndexSize)
{
  check(HashSize == 0u);
  check(IndexSize == 0u);

  HashSize = InHashSize;
  IndexSize = InIndexSize;

  check(HashSize <= 0x10000);
  check(FMath::IsPowerOfTwo(HashSize));

  if (IndexSize)
  {
    HashMask = (uint16)(HashSize - 1);

    Hash = new uint32[HashSize];
    NextIndex = new uint32[IndexSize];

    FMemory::Memset(Hash, 0xff, HashSize * 4);
  }
}

在Initialize时会检测当前的HashSize和IndexSize是否为0，并在之后进行赋值。所以，我们只要获取FHashTable的HashSize和IndexSize检测它们是否为0即可判断当前的HashTable对象是否已经被Initialize过，但是，UE里的FHashTable里这两个成员都是protected的，只能修改引擎来实现了：

添加获取FHashTable的HashSize和IndexSize属性的成员函数：

1
2
3
4
5
6
7
8
class FHashTable
{
public:
  // ...
  FORCEINLINE uint32 GetHashSize()const{return HashSize;};
  FORCEINLINE uint32 GetIndexSize()const{return IndexSize;};
  // ...
};

然后在FSerializedShaderArchive::Serialize进行检测，如果已被初始化则跳过Initialize逻辑：

Runtime/RenderCore/Private/ShaderCodeArchive.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
void FSerializedShaderArchive::Serialize(FArchive& Ar)
{
  Ar << ShaderMapHashes;
  Ar << ShaderHashes;
  Ar << ShaderMapEntries;
  Ar << ShaderEntries;
  Ar << PreloadEntries;
  Ar << ShaderIndices;

  check(ShaderHashes.Num() == ShaderEntries.Num());
  check(ShaderMapHashes.Num() == ShaderMapEntries.Num());

  if (Ar.IsLoading())
  {
    // ++[SHADER_PATCH][lipengzha]
    auto ShaderHashInitialized = [](const FHashTable& HashTable)->bool
    {
      return HashTable.GetHashSize() || HashTable.GetIndexSize();
    };
    // ++[SHADER_PATCH][lipengzha]
    {
      const uint32 HashSize = FMath::Min<uint32>(0x10000, 1u << FMath::CeilLogTwo(ShaderMapHashes.Num()));
      
      // ++[SHADER_PATCH][lipengzha]
      if(!ShaderHashInitialized(ShaderMapHashTable))
      {
        ShaderMapHashTable.Initialize(HashSize, ShaderMapHashes.Num());
      }
      // ++[SHADER_PATCH][lipengzha]
      
      for (int32 Index = 0; Index < ShaderMapHashes.Num(); ++Index)
      {
        const uint32 Key = GetTypeHash(ShaderMapHashes[Index]);
        ShaderMapHashTable.Add(Key, Index);
      }
    }
    {
      const uint32 HashSize = FMath::Min<uint32>(0x10000, 1u << FMath::CeilLogTwo(ShaderHashes.Num()));
      
      // ++[SHADER_PATCH][lipengzha]
      if(!ShaderHashInitialized(ShaderHashTable))
      {
        ShaderHashTable.Initialize(HashSize, ShaderHashes.Num());
      }
      // ++[SHADER_PATCH][lipengzha]
      
      for (int32 Index = 0; Index < ShaderHashes.Num(); ++Index)
      {
        const uint32 Key = GetTypeHash(ShaderHashes[Index]);
        ShaderHashTable.Add(Key, Index);
      }
    }
  }
}

这样可以统一ShaderPatch和Runtime的HashTable的Initialize流程。

而且，需要注意的是：生成出来的ShaderPatch的ushaderbytecode文件是与基础包内的文件名一致的，所以不能使用引擎启动时的默认挂载（会导致基础包内的ushaderbytecode文件无法被加载，从而crash）。

应该在挂载之后自己处理ShaderPatch的ushaderbytecode文件的加载，使用以下函数加载：

1
2
3
4
bool UFlibPatchParserHelper::LoadShaderbytecode(const FString& LibraryName, const FString& LibraryDir)
{
  return FShaderCodeLibrary::OpenLibrary(LibraryName, LibraryDir);
}

注意：ShaderPatch的更新不直接支持Patch的迭代，如：1.0 Metadata + 1.1的ShaderPatch，并不能生成1.2的ShaderPatch，必须要基于1.1的完整Metadata才可以，即每次Patch必须要基于上一次完整的Metadate数据（Project和Global的ushaderbytecode文件），在工程管理上每次打包都需要把完整的Metadata收集起来。

Win和Mac出IOS包的区别

UE支持以远程构建的方式来出IOS包，Mac上只编译代码，Cook和编译shader等操作在Win上执行，生成的ios包使用ushaderbytecode，而在Mac上打包IOS则会使用Matellib。

Metallib是IOS上的原生shader格式，远程构建出包的ushaderbytecode是Text Shader，在运行时加载实时编译，效率上是有比较大差距的。
在UE4.26提供了在Win上编译Metal原生Shader的方法，在4.25及之前的引擎只能使用Enable Shader Compile了。

UE4新地图的Package问题

发现UE中的一个问题：

  1. 创建一个新的地图
  2. 获取这个新地图的UPackage，得到的是Engine/Maps/Templates/Template_Default

但是在第二次启动的时候就正常了，怀疑是新建资源的时候没有更新AssetRegistry，有时间具体分析一下原因。

C++加载BP的Enum

在蓝图中新建的枚举资源，在C++中访问：

1
2
3
4
5
6
7
8
9
10
FString UFlibAppHelper::GetEnumNameByValue(TSoftObjectPtr<UUserDefinedEnum> EnumPath, int32 value)
{
    FString result;
    UUserDefinedEnum* Enumer = LoadObject<UUserDefinedEnum>(nullptr, *EnumPath.ToString());
    if (Enumer)
    {
        result = Enumer->GetDisplayNameTextByValue(value).ToString();
    }
    return result;
}

效果：

DS设置超时时间

修改DefaultEngine.ini：

1
2
[/Script/OnlineSubsystemUtils.IpNetDriver]
ConnectionTimeout=10.0

DDC的资料

路径过长导致远程构建失败

当引擎的路径过长时，远程构建会出现以下错误：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  ********** BUILD COMMAND STARTED **********
  Running: C:\BuildAgent\workspace\PackageWindows\InstalledEngine\Engine\Engine\Binaries\DotNET\UnrealBuildTool.exe FGame IOS Development -Project=C:\BuildAgent\workspace\PackageW
indows\Client\FGame.uproject  C:\BuildAgent\workspace\PackageWindows\Client\FGame.uproject -NoUBTMakefiles  -remoteini="C:\BuildAgent\workspace\PackageWindows\Client" -skipdeploy 
-Manifest=C:\BuildAgent\workspace\PackageWindows\Client\Intermediate\Build\Manifest.xml -NoHotReload -log="C:\Users\lipengzha\AppData\Roaming\Unreal Engine\AutomationTool\Logs\C+B
uildAgent+workspace+PackageWindows+InstalledEngine+Engine\BuildCookRun\UBT-FGame-IOS-Development.txt"
    WARNING: Running from a path with a long directory name ("C:\BuildAgent\workspace\PackageWindows\InstalledEngine\Engine" = 61 characters). Root paths shorter than 50 character
s are recommended to avoid exceeding maximum path lengths on Windows.
    [Remote] Using remote server 'xx.xx.xx.xx' on port 2222 (user 'buildmachine')
    [Remote] Using private key at C:\BuildAgent\workspace\PackageWindows\Client\Build\NotForLicensees\SSHKeys\xx.xx.xx.xx\buildmachine\RemoteToolChainPrivate.key
    ERROR: Unable to determine home directory for remote user. SSH output:
             Host key verification failed.
  Took 0.8051806s to run UnrealBuildTool.exe, ExitCode=6
  UnrealBuildTool failed. See log for more details. (C:\Users\lipengzha\AppData\Roaming\Unreal Engine\AutomationTool\Logs\C+BuildAgent+workspace+PackageWindows+InstalledEngine+Eng
ine\BuildCookRun\UBT-FGame-IOS-Development.txt)
  AutomationTool exiting with ExitCode=6 (6)
Took 1.6488741s to run AutomationTool.exe, ExitCode=6
AutomationTool exiting with ExitCode=1 (Error_Unknown)
BUILD FAILED

这里有一个Running from a path with a long directory name的警告，然后跟着一个SSH Key的验证错误。
造成这个错误的原因就是因为警告中的内容，而非SSHKey的问题，因为Win默认的路径长度不能长于260，所以当引擎根目录位于较深的目录中时，可能会导致引擎的路径超过限制，导致后续的失败。

解决方案自然就是两个办法：

  1. 减少引擎的路径深度
  2. 修改系统的最长路径支持

Win10现在支持了长路径支持，开启即可：Win10 开启长路径支持

Mount Point的作用

在Mount Pak的时候，有一个参数可以指定MountPoint:

1
2
3
4
5
6
7
/**
* Mounts a pak file at the specified path.
*
* @param InPakFilename Pak filename.
* @param InPath Path to mount the pak at.
*/
bool Mount(const TCHAR* InPakFilename, uint32 PakOrder, const TCHAR* InPath = NULL, bool bLoadIndex = true);

那么它是干什么的呢？
首先从Mount函数开始：

1
2
3
4
if (InPath != NULL)
{
  Pak->SetMountPoint(InPath);
}

如果在调用Mount时传递了InPath，则通过加载Pak的FPakFile实例调用SetMountPoint，把InPath设置给它。
其实在FPakFile中，MountPath是有默认值的（从Pak文件中读取），在FPakFile的构造函数中调用了Initialize(Reader, bLoadIndex);，Initialize中又调用了LoadIndex，在LoadIndex中从Pak中读取Pak的Mount Point的逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// Runtime/PakFile/Private/IPlatformFilePak.cpp
void FPakFile::LoadIndex(FArchive* Reader)
{
  if (CachedTotalSize < (Info.IndexOffset + Info.IndexSize))
  {
    UE_LOG(LogPakFile, Fatal, TEXT("Corrupted index offset in pak file."));
  }
  else
  {
    if (Info.Version >= FPakInfo::PakFile_Version_FrozenIndex && Info.bIndexIsFrozen)
    {
      SCOPED_BOOT_TIMING("PakFile_LoadFrozen");

      // read frozen data
      Reader->Seek(Info.IndexOffset);
      int32 FrozenSize = Info.IndexSize;

      // read in the index, etc data in one lump
      void* DataMemory = FMemory::Malloc(FrozenSize);
      Reader->Serialize(DataMemory, FrozenSize);
      Data = TUniquePtr<FPakFileData>((FPakFileData*)DataMemory);

      // cache the number of entries
      NumEntries = Data->Files.Num();
      // @todo loadtime: it is nice to serialize the mountpoint right into the Data so that IndexSize is right here
      // but it takes this to copy it out, because it's too painful for the string manipulation when dealing with
      // MemoryImageString everywhere MountPoint is used
      MountPoint = Data->MountPoint;
    }
      // ...
    }
  // ...
}

简单的可以理解为：如果Mount时不传递Mount Point就会从Pak文件中读取，如果有传入就设置为传入的值（Pak文件中的MountPoint是Pak中所有文件的公共路径）。

那么，给Pak设置MountPoint的作用是什么呢？
真实目的是，检测要加载的文件是否存在于当前Pak中！因为Pak的Mount Point的默认含义是当前Pak中所有文件的公共路径，所以只需要检测要读取的文件是否以这个路径开头，就可以首先排除掉基础路径不对的文件（基础路径都不对，意味着这个文件在Pak中也不存在）。

具体逻辑可以看这个函数的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// Runtime/PakFile/Public/IPlatformFilePak.h
/**
* Finds a file in the specified pak files.
*
* @param Paks Pak files to find the file in.
* @param Filename File to find in pak files.
* @param OutPakFile Optional pointer to a pak file where the filename was found.
* @return Pointer to pak entry if the file was found, NULL otherwise.
*/
static bool FindFileInPakFiles(TArray<FPakListEntry>& Paks,const TCHAR* Filename,FPakFile** OutPakFile,FPakEntry* OutEntry = nullptr)
{
    FString StandardFilename(Filename);
    FPaths::MakeStandardFilename(StandardFilename);

    int32 DeletedReadOrder = -1;

    for (int32 PakIndex = 0; PakIndex < Paks.Num(); PakIndex++)
    {
        int32 PakReadOrder = Paks[PakIndex].ReadOrder;
        if (DeletedReadOrder != -1 && DeletedReadOrder > PakReadOrder)
        {
            //found a delete record in a higher priority patch level, but now we're at a lower priority set - don't search further back or we'll find the original, old file.
            UE_LOG( LogPakFile, Verbose, TEXT("Delete Record: Accepted a delete record for %s"), Filename );
            return false;
        }

        FPakFile::EFindResult FindResult = Paks[PakIndex].PakFile->Find(*StandardFilename, OutEntry);
        if (FindResult == FPakFile::EFindResult::Found )
        {
            if (OutPakFile != NULL)
            {
                *OutPakFile = Paks[PakIndex].PakFile;
            }
            UE_CLOG( DeletedReadOrder != -1, LogPakFile, Verbose, TEXT("Delete Record: Ignored delete record for %s - found it in %s instead (asset was moved between chunks)"), Filename, *Paks[PakIndex].PakFile->GetFilename() );
            return true;
        }
        else if (FindResult == FPakFile::EFindResult::FoundDeleted )
        {
            DeletedReadOrder = PakReadOrder;
            UE_LOG( LogPakFile, Verbose, TEXT("Delete Record: Found a delete record for %s in %s"), Filename, *Paks[PakIndex].PakFile->GetFilename() );
        }
    }

    UE_CLOG( DeletedReadOrder != -1, LogPakFile, Warning, TEXT("Delete Record: No lower priority pak files looking for %s. (maybe not downloaded?)"), Filename );
    return false;
}

当我们从Pak中读取文件时，通过对游戏中所有Mount的Pak调用Find函数，而FPakFile::Find的函数就实现了上述我说的逻辑：

1
2
3
4
5
6
7
8
9
10
11
// Runtime/PakFile/Private/IPlatformFilePak.cpp
FPakFile::EFindResult FPakFile::Find(const FString& Filename, FPakEntry* OutEntry) const
{
  QUICK_SCOPE_CYCLE_COUNTER(PakFileFind);
  if (Filename.StartsWith(MountPoint))
  {
    FString Path(FPaths::GetPath(Filename));
      // ...
    }
  // ...
}

所以，MountPoint的作用就是在从Pak中查找文件时，首先判断文件的路径是否与Pak中所有文件的基础路径相匹配（StartWith），如果不存在也就不会进入后续的流程了。

引擎的Splash过程

通过在这里断点可以比较直观地分析，引擎初始化到什么阶段做了什么事情。

UE4.25.1的Assembly路径错误

在UE4.25.1中，引擎生成的Engine/Intermediate/Build/BuildRules/UE4Rules.dll等文件具有路径错误。

具体的原因是在UnrealBuildTool/System/RulesCompiler.cs的CreateEngineOrEnterpriseRulesAssembly函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// UE 4.25.1
private static RulesAssembly CreateEngineOrEnterpriseRulesAssembly(RulesScope Scope, List<DirectoryReference> RootDirectories, string AssemblyPrefix, IReadOnlyList<PluginInfo> Plugins, bool bReadOnly, bool bSkipCompile, RulesAssembly Parent)
{
  // ...
  // Get the path to store any generated assemblies
  DirectoryReference AssemblyDir = RootDirectories[0];
  if (UnrealBuildTool.IsFileInstalled(FileReference.Combine(AssemblyDir, AssemblyPrefix)))
  {
  DirectoryReference UserDir = Utils.GetUserSettingDirectory();
      if (UserDir != null)
  {
      ReadOnlyBuildVersion Version = ReadOnlyBuildVersion.Current;
      AssemblyDir = DirectoryReference.Combine(UserDir, "UnrealEngine", String.Format("{0}.{1}", Version.MajorVersion, Version.MinorVersion));
  }
  }

  // Create the assembly
  FileReference EngineAssemblyFileName = FileReference.Combine(AssemblyDir, "Intermediate", "Build", "BuildRules", AssemblyPrefix + "Rules" + FrameworkAssemblyExtension);
  RulesAssembly EngineAssembly = new RulesAssembly(Scope, RootDirectories, Plugins, ModuleFileToContext, new List<FileReference>(), EngineAssemblyFileName, bContainsEngineModules: true, DefaultBuildSettings: BuildSettingsVersion.Latest, bReadOnly: bReadOnly, bSkipCompile: bSkipCompile, Parent: Parent);
  //...
}

上面的代码中AssemblyDir是引擎目录，AssemblyPrefix是UE4，拼接起来能够通过UnrealBuildTool.IsFileInstalled的检测。
但是，在if的代码块中，获取了用户目录，在IOS中就是：

1
2
3
4
# win
C:\Users\lipengzha\AppData\Local\UnrealEngine\4.25
# Mac
/Users/buildmachine/Library/Application Support/Epic

拼接起来就是上面这两个USER_DIR的UnrealEngine/4.25/，在下面读取Assembly的流程中就会使用这个路径。

在使用Win的时候，其实没有问题，因为就算把UE4Rules.dll写入到用户目录下，在Win上同样是可以访问到的。但是，在使用Win远程构建IOS的时候就会出现问题。
在远程构建时，会使用Rsync把引擎的文件同步到Mac上再执行编译，其中就包括Engine/Intermediate/Build/BuildRuls/下的所有文件，因为4.25.1中的代码会把Build/BuildRuls/UE4Rules.dll等生成到Win的用户目录下，所以远程构建，RSync就不能正确地把BuildRuls下的文件上传到Mac上，故而引起打包错误：

1
2
ERROR: Precompiled rules assembly '/Users/buildmachine/Library/Application Support/Epic/UnrealEngine/4.25/Intermediate/Build/BuildRules/UE4Rules.dl
l' does not exist.

可以看到，在Mac上也是从Mac的用户目录查找的，因为压根Mac上就没有这俩文件，所以就会产生这个错误。
解决这个问题的办法，就是修改UnrealBuildTool/System/RulesCompiler.cs的CreateEngineOrEnterpriseRulesAssembly函数，把BuildRules相关的文件写入到Engine/Intermediate/Build/BuildRules中，在UE4.25.2中已经修复了这个错误。
在4.25.2 Hotfix released中列出了Fixed! UE-94140 Fix assembly location for remote toolchain，其实就是直接修改了CreateEngineOrEnterpriseRulesAssembly函数:

1
2
3
4
5
6
7
8
9
// UE 4.25.2
private static RulesAssembly CreateEngineOrEnterpriseRulesAssembly(RulesScope Scope, List<DirectoryReference> RootDirectories, string AssemblyPrefix, IReadOnlyList<PluginInfo> Plugins, bool bReadOnly, bool bSkipCompile, RulesAssembly Parent)
{
  // ...
  // Create the assembly
  FileReference EngineAssemblyFileName = FileReference.Combine(RootDirectories[0], "Intermediate", "Build", "BuildRules", AssemblyPrefix + "Rules" + FrameworkAssemblyExtension);
  RulesAssembly EngineAssembly = new RulesAssembly(Scope, RootDirectories[0], Plugins, ModuleFileToContext, new List<FileReference>(), EngineAssemblyFileName, bContainsEngineModules: true, DefaultBuildSettings: BuildSettingsVersion.Latest, bReadOnly: bReadOnly, bSkipCompile: bSkipCompile, Parent: Parent);
  // ...
}

可以直接在github中查看:UnrealBuildTool/System/RulesCompiler.cs#L442

跨Level选择Actor

在场景中，美术和游戏逻辑是区分开的，所以有时候需要程序关卡去操控美术关卡的对象，但是UE的不同关卡其实是不同的资源，属于不同的Pacakge，是不能直接跨关卡来选择对象实例的。
选择时会有以下错误：

1
LogProperty: Warning: Illegal TEXT reference to a private object in external package (StaticMeshActor /Game/Test/Map/Level_Sub2.Level_Sub2:PersistentLevel.Cube_2) from referencer (BP_AActor_C /Game/Test/Map/Level_Sub1.Level_Sub1:PersistentLevel.BP_AActor_2).  Import failed...

这是因为在PropertyBaseObject.cpp的FObjectPropertyBase::ImportText_Internal中对Object属性是否可以跨关卡做了检测：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
UObject* FObjectPropertyBase::FindImportedObject( const FProperty* Property, UObject* OwnerObject, UClass* ObjectClass, UClass* RequiredMetaClass, const TCHAR* Text, uint32 PortFlags/*=0*/, FUObjectSerializeContext* InSerializeContext /*= nullptr*/, bool bAllowAnyPackage /*= true*/)
{
    // ...
	// if we found an object, and we have a parent, make sure we are in the same package if the found object is private, unless it's a cross level property
	if (Result && !Result->HasAnyFlags(RF_Public) && OwnerObject && Result->GetOutermost() != OwnerObject->GetOutermost())
	{
		const FObjectPropertyBase* ObjectProperty = CastField<const FObjectPropertyBase>(Property);
		if ( !ObjectProperty || !ObjectProperty->AllowCrossLevel())
		{
			UE_LOG(LogProperty, Warning, TEXT("Illegal TEXT reference to a private object in external package (%s) from referencer (%s).  Import failed..."), *Result->GetFullName(), *OwnerObject->GetFullName());
			Result = nullptr;
		}
	}
    // ...
}

其中AllowCrossLevel有两个继承类有覆写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Runtime/CoreUObject/Private/UObject/PropertyBaseObject.cpp
bool FObjectPropertyBase::AllowCrossLevel() const
{
	return false;
}
// Runtime/CoreUObject/Private/UObject/PropertyLazyObjectPtr.cpp
bool FLazyObjectProperty::AllowCrossLevel() const
{
	return true;
}
// Runtime/CoreUObject/Private/UObject/PropertySoftObjectPtr.cpp
bool FSoftObjectProperty::AllowCrossLevel() const
{
	return true;
}

所以，不能够直接通过创建FObjectPropertyBase这种硬引用方式的属性从SubLevel1选择SubLevel2中的Actor。
那么如何解决这么问题呢？，上面已经列出了两个可以跨平台选择的属性，分别是FLazyObjectProperty和FSoftObjectProperty，那么以FSoftObjectProperty为例，可以通过TSoftObjectPtr来实现：

1
TSoftObjectPtr<AActor> Actor;

TSoftObjectPtr获取到的其实是SubLevel2中的资源的路径：

1
/Game/Test/Map/Level_Sub2.Level_Sub2:PersistentLevel.Cube_2

在运行时访问需要使用以下操作来获取：

上面蓝图中节点Load Asset Blocking是UKismetSystemLibrary中的函数：

1
2
3
4
5
// Runtime/Engine/Private/KismetSystemLibrary.cpp
UObject* UKismetSystemLibrary::LoadAsset_Blocking(TSoftObjectPtr<UObject> Asset)
{
	return Asset.LoadSynchronous();
}

看来UE加载资源时，并没有区分真正的物理资源和场景中的实例，统一使用资源的路径来加载，这一点做的非常爽，可以把另一个关卡中的Actor当作资源来读取，并且获取的还就是运行时的那个实例，非常Nice。

添加外部库的注意事项

在添加外部的代码库时，需要关注以下几个问题：

  1. 纯代码的库，要测试是否具有平台相关的写法，需要同时支持Win/Android/IOS/Mac四个平台
  2. 对于Android的so要同时支持arm64/armv7，打包时so文件的拷贝需要使用UPL执行
  3. ios的.a要同时具有bitcode和非bitcode版本，不然在shipping时如果开启了bitcode，链接不支持bitcode的库会有链接错误的问题。

检测当前构建是否支持bitcode的流程：

1
2
3
4
5
6
7
8
if (Target.IOSPlatform.bShipForBitcode)
{
	// add support bitcode lib
}

{
	// add not-support bitcode lib
}

在Target.cs中可以直接通过IOSPlatform获取当前构建是否支持bitcode，在其他的Module中，可以通过target.cs中的Target.IOSPlatform获取。

Outer

获取ContentBrowser中选择的资源

1
2
3
4
5
6
7
8
#include "IContentBrowserSingleton.h"
TArray<FAssetData> FHotPatcherEditorModule::GetSelectedAssetsInBrowserContent()
{
	FContentBrowserModule& ContentBrowserModule = FModuleManager::Get().LoadModuleChecked<FContentBrowserModule>(TEXT("ContentBrowser"));
	TArray<FAssetData> AssetsData;
	ContentBrowserModule.Get().GetSelectedAssets(AssetsData);
	return AssetsData;
}

命令行太长无法适应调试记录

1
无法执行“C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.16.27023\bin\HostX64\x64\c1xx.dll”: 命令行太长，无法适应调试记录

在报错的模块的build.cs中添加下列属性即可：

1
bLegacyPublicIncludePaths = false;

添加资源右键菜单按钮

在ContentBrowser选择资源时的右键菜单按钮。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void FHotPatcherEditorModule::AddAssetContentMenu()
{
	if (!UToolMenus::IsToolMenuUIEnabled())
	{
		return;
	}
 
	FToolMenuOwnerScoped MenuOwner("CookUtilities");
	UToolMenu* Menu = UToolMenus::Get()->ExtendMenu("ContentBrowser.AssetContextMenu");
	FToolMenuSection& Section = Menu->AddSection("AssetContextCookUtilities", LOCTEXT("CookUtilitiesMenuHeading", "CookUtilities"));;
	
	Section.AddDynamicEntry("SoundWaveAsset", FNewToolMenuSectionDelegate::CreateLambda([this](FToolMenuSection& InSection)
	   {
	       const TAttribute<FText> Label = LOCTEXT("CookUtilities_CookAsset", "Cook Assets");
	       const TAttribute<FText> ToolTip = LOCTEXT("CookUtilities_CookAssetsTooltip", "Cook Assets");
	       const FSlateIcon Icon = FSlateIcon(FEditorStyle::GetStyleSetName(), "ClassIcon.SoundSimple");
	       const FToolMenuExecuteAction UIAction = FToolMenuExecuteAction::CreateRaw(this,&FHotPatcherEditorModule::OnCookAssets);
	
	       InSection.AddMenuEntry("CookUtilities_CookAssets", Label, ToolTip, Icon, UIAction);
	   }));
}

可以在绑定的函数中对资源进行操作。

GenerateProjectFiles指定VS版本

GenerateProjectFiles.bat最终也是调用到UnrealBuildTool.exe，可以通过-2015/-2017来指定VS2015和VS2017引擎版本。

Module的WhitelistPlatforms

有一些Module用到了平台相关的内容，在另一个平台会编译不过，所以需要在uplugin中给Module添加模块白名单，只有在其中的平台上才会进行编译。

1
2
3
4
5
6
7
8
9
10
11
"Modules": [
{
	"Name": "OculusHMD",
	"Type": "Runtime",
	"LoadingPhase": "PostConfigInit",
	"WhitelistPlatforms": [
		"Win64",
		"Win32",
		"Android"
	]
},

也可以设置平台的黑名单，使用BlacklistPlatforms。

IDetailCustomization

使用IDetailCustomization的方式可以给UE的属性面板添加特殊的东西，比如按钮。

以给F的结构的Detail添加按钮的方法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
// ReleaseSettingsDetails.h
#pragma once
#include "IDetailCustomization.h"

class FReleaseSettingsDetails : public IDetailCustomization
{
public:
    /** Makes a new instance of this detail layout class for a specific detail view requesting it */
    static TSharedRef<IDetailCustomization> MakeInstance();

    /** IDetailCustomization interface */
    virtual void CustomizeDetails(IDetailLayoutBuilder& DetailBuilder) override;
};

.cpp:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
// ReleaseSettingsDetails.cpp
#include "CreatePatch/ReleaseSettingsDetails.h"
#include "CreatePatch/FExportReleaseSettings.h"

// engine header
#include "DetailLayoutBuilder.h"
#include "DetailCategoryBuilder.h"
#include "DetailWidgetRow.h"
#include "Widgets/Input/SButton.h"

#define LOCTEXT_NAMESPACE "ReleaseSettingsDetails"

TSharedRef<IDetailCustomization> FReleaseSettingsDetails::MakeInstance()
{
    return MakeShareable(new FReleaseSettingsDetails());
}

void FReleaseSettingsDetails::CustomizeDetails(IDetailLayoutBuilder& DetailBuilder)
{
    TArray< TSharedPtr<FStructOnScope> > StructBeingCustomized;
    DetailBuilder.GetStructsBeingCustomized(StructBeingCustomized);
    check(StructBeingCustomized.Num() == 1);
    
    FExportReleaseSettings* ReleaseSettingsIns = (FExportReleaseSettings*)StructBeingCustomized[0].Get()->GetStructMemory();
    
    IDetailCategoryBuilder& VersionCategory = DetailBuilder.EditCategory("Version",FText::GetEmpty(),ECategoryPriority::Default);
    VersionCategory.SetShowAdvanced(true);
    
    VersionCategory.AddCustomRow(LOCTEXT("ImportPakLists", "Import Pak Lists"),true)
        .ValueContent()
        [
            SNew(SHorizontalBox)
            + SHorizontalBox::Slot()
            .Padding(0)
            .AutoWidth()
            [
                SNew(SButton)
                .Text(LOCTEXT("Import", "Import"))
                .ToolTipText(LOCTEXT("ImportPakLists_Tooltip", "Import Pak Lists"))
                .IsEnabled_Lambda([this,ReleaseSettingsIns]()->bool
                {
                    return ReleaseSettingsIns->IsByPakList();
                })
                .OnClicked_Lambda([this, ReleaseSettingsIns]()
                {
                    if (ReleaseSettingsIns)
                    {
                        ReleaseSettingsIns->ImportPakLists();
                    }
                    return(FReply::Handled());
                })
            ]
            + SHorizontalBox::Slot()
            .Padding(5,0,0,0)
            .AutoWidth()
            [
                SNew(SButton)
                .Text(LOCTEXT("Clear", "Clear"))
                .ToolTipText(LOCTEXT("ClearPakLists_Tooltip", "Clear Pak Lists"))
                .IsEnabled_Lambda([this,ReleaseSettingsIns]()->bool
                {
                    return ReleaseSettingsIns->IsByPakList();
                })
                .OnClicked_Lambda([this, ReleaseSettingsIns]()
                {
                    if (ReleaseSettingsIns)
                    {
                        ReleaseSettingsIns->ClearImportedPakList();
                    }
                    return(FReply::Handled());
                })
            ]
        ];
}
#undef LOCTEXT_NAMESPACE

这里我们只是定义了一个IDetailCustomization的类，其中的CustomizeDetails是对FExportReleaseSettings添加的细节。

该类在创建DetailView时使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
void SHotPatcherExportRelease::CreateExportFilterListView()
{
	// Create a property view
	FPropertyEditorModule& EditModule = FModuleManager::Get().GetModuleChecked<FPropertyEditorModule>("PropertyEditor");

	FDetailsViewArgs DetailsViewArgs;
	{
		DetailsViewArgs.bAllowSearch = true;
		DetailsViewArgs.bHideSelectionTip = true;
		DetailsViewArgs.bLockable = false;
		DetailsViewArgs.bSearchInitialKeyFocus = true;
		DetailsViewArgs.bUpdatesFromSelection = false;
		DetailsViewArgs.NotifyHook = nullptr;
		DetailsViewArgs.bShowOptions = true;
		DetailsViewArgs.bShowModifiedPropertiesOption = false;
		DetailsViewArgs.bShowScrollBar = false;
		DetailsViewArgs.bShowOptions = true;
		DetailsViewArgs.bUpdatesFromSelection= true;
	}

	FStructureDetailsViewArgs StructureViewArgs;
	{
		StructureViewArgs.bShowObjects = true;
		StructureViewArgs.bShowAssets = true;
		StructureViewArgs.bShowClasses = true;
		StructureViewArgs.bShowInterfaces = true;
	}

	SettingsView = EditModule.CreateStructureDetailView(DetailsViewArgs, StructureViewArgs, nullptr);
	FStructOnScope* Struct = new FStructOnScope(FExportReleaseSettings::StaticStruct(), (uint8*)ExportReleaseSettings.Get());
	SettingsView->GetOnFinishedChangingPropertiesDelegate().AddRaw(ExportReleaseSettings.Get(),&FExportReleaseSettings::OnFinishedChangingProperties);
	SettingsView->GetDetailsView()->RegisterInstancedCustomPropertyLayout(FExportReleaseSettings::StaticStruct(),FOnGetDetailCustomizationInstance::CreateStatic(&FReleaseSettingsDetails::MakeInstance));
	SettingsView->SetStructureData(MakeShareable(Struct));
}

使用RegisterInstancedCustomPropertyLayout把所写的FReleaseSettingsDetails实例注册到DetailView中。注意调用时机要在SetStructureData之前。
然后就可以看到添加的两个按钮了：

提取PakList文件

打包时生成的PakList*.txt文件存放位置为：

1
Engine\Programs\AutomationTool\Saved\Logs

PakList的命名规则为PakList_PROJECTNAME_PLATFORM.txt，如：

1
2
3
PakList_Blank425-WindowsNoEditor.txt
PakList_Blank425-Android_ASTC.txt
PakList_blank425-ios.txt

但是UE在打包下一次时会把上一次生成的PakList*.txt文件给清理掉。所以如果要提取某个平台的PakList需要在打包完当前平台之后立即提取，不然打包下个平台就把之前的删掉了。

绑定DetailsView的属性变化事件

在编辑器中创建DetailsView时，如果使用继承自UObject的对象，可以重载PostEditChangeProperty来实现属性变化的监听，但是如果使用F的结构，则不能直接在类的函数中监听，需要通过绑定IStructureDetailsView的属性变动代理：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
TSharedPtr<IStructureDetailsView> SettingsView;

// Create a property view
FPropertyEditorModule& EditModule = FModuleManager::Get().GetModuleChecked<FPropertyEditorModule>("PropertyEditor");

FDetailsViewArgs DetailsViewArgs;
{
	DetailsViewArgs.bAllowSearch = true;
	DetailsViewArgs.bHideSelectionTip = true;
	DetailsViewArgs.bLockable = false;
	DetailsViewArgs.bSearchInitialKeyFocus = true;
	DetailsViewArgs.bUpdatesFromSelection = false;
	DetailsViewArgs.NotifyHook = nullptr;
	DetailsViewArgs.bShowOptions = true;
	DetailsViewArgs.bShowModifiedPropertiesOption = false;
	DetailsViewArgs.bShowScrollBar = false;
	DetailsViewArgs.bShowOptions = true;
	DetailsViewArgs.bUpdatesFromSelection= true;
}

FStructureDetailsViewArgs StructureViewArgs;
{
	StructureViewArgs.bShowObjects = true;
	StructureViewArgs.bShowAssets = true;
	StructureViewArgs.bShowClasses = true;
	StructureViewArgs.bShowInterfaces = true;
}

SettingsView = EditModule.CreateStructureDetailView(DetailsViewArgs, StructureViewArgs, nullptr);
FStructOnScope* Struct = new FStructOnScope(FExportReleaseSettings::StaticStruct(), (uint8*)ExportReleaseSettings.Get());
SettingsView->GetOnFinishedChangingPropertiesDelegate().AddRaw(ExportReleaseSettings.Get(),&FExportReleaseSettings::OnFinishedChangingProperties);
SettingsView->SetStructureData(MakeShareable(Struct));

关键是这行代码：

1
SettingsView->GetOnFinishedChangingPropertiesDelegate().AddRaw(ExportReleaseSettings.Get(),&FExportReleaseSettings::OnFinishedChangingProperties);

把当前DetailsView的属性变动事件绑定到OnFinishedChangingProperties上。

从指定Pak加载文件

具体可以看FPakPlatformFile::OpenRead的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
IFileHandle* FPakPlatformFile::OpenRead(const TCHAR* Filename, bool bAllowWrite)
{
	IFileHandle* Result = NULL;
	FPakFile* PakFile = NULL;
	FPakEntry FileEntry;
	if (FindFileInPakFiles(Filename, &PakFile, &FileEntry))
	{
#if PAK_TRACKER
		TrackPak(Filename, &FileEntry);
#endif

		Result = CreatePakFileHandle(Filename, PakFile, &FileEntry);

		if (Result)
		{
			FCoreDelegates::OnFileOpenedForReadFromPakFile.Broadcast(*PakFile->GetFilename(), Filename)