Unity - 搬砖日志 - Occlusion Culling 关闭动态遮挡剔除 Renderer.allowOcclusionWhenDynamic = false

---

CullDynamicObjectsWithUmbra 消耗

Umbra 是 unity 自带的 OC(Occlusion Culling) 的算法的、架构的名字

所以 CullDynamicObjectsWithUmbra 是 对动态对象进行遮挡剔除时的消耗，如下图：

上面的测试数据是基于 小米5 真机上测试的

可以看到 Profiler : PlayerLoop/PostLateUpdate.FinishFrameRendering/Camera.Render/Culling/SceneCulling/CullSendEvents/WaitForJobGroupID/CullSceneDynamicObjects/CullDynamicObjectsWithUmbra 的消耗是有一部分的，消耗了 3.12 ms

---

如何禁止 动态对象的遮挡剔除的消耗

• 不开启 OC（Camera.useOcclusionCulling = false）
• Renderer 的 Renderer.allowOcclusionWhenDynamic = false

但如果你想保留 静态 OC，只是想关闭动态 OC，那么就需要将所有的 Renderer.allowOcclusionWhenDynamic = false

但是我们官方手册、论坛、国内 baidu, 国外 google 过，都没有找到如果关闭 Umbra 的动态遮挡剔除的总开光（如果有 unity 源码的话，就不至于这么蛋疼了）

下面是禁止动态 OC 后的 profiler 结果，但是截图的红框框中的内框错了，应该是框那个：CullDynamicObjectsWithUmbra 的部分，可以看到这部分的消耗是未 0.00 s 的消耗了

然后上图是通过脚本遍历大部分 Renderer ，并设置： allowOcclusionWhenDynamic = false; （还有大概3~4 个墙体，地表，等，没有禁用，所以还是有一丢丢消耗），设置的脚本如下：

写工具来遍历 Renderer.allowOcclusionWhenDynamic = false

    public void OnToggleDynamicObjOC()
    {
        renderers.Clear();
        dynamicObjRoot.GetComponentsInChildren<Renderer>(true, renderers);

        var setValue = !curEnabledDynamicOC;

        for (int i = 0; i < renderers.Count; i++)
        {
            var renderer = renderers[i];
            renderer.allowOcclusionWhenDynamic = setValue;
        }

        curEnabledDynamicOC = setValue;

        toggleDyanmicOCBtnText.text = $"Cur DynamicOC : {setValue}";
    }

在 Unity 官方 API 文档，还有 Unity 论坛上，Baidu, Goggle 都没有找到 Unity 有暴露一个总开关的地方
（除非有 Unity 源码，可以自行扩展出一个给 C# 脚本控制的总开关，否则只能用回上面的脚本遍历处理）

而工具刚刚写好，就一个脚本完事：

// jave.lin 2021/08/05
// 禁用 Renderer dynamic OC 的工具

using System;
using System.Collections.Generic;
using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEngine;
using UnityEngine.SceneManagement;

public class DisableRendererOCEditorWindow : EditorWindow
{
    public enum eDisableRet
    {
        Success,
        Cancel,
        Error,
    }

    private List<Renderer> renderersHelper = new List<Renderer>();
    private HashSet<string> handledSetsHelper = new HashSet<string>();

    [MenuItem("Tools/资源工具/禁用 Renderer dynamic OC 的工具")]
    public static void _Show()
    {
        var win = EditorWindow.GetWindow<DisableRendererOCEditorWindow>();
        win.titleContent = new GUIContent("禁用 Renderer dynamic OC 的工具");
        win.Show();
    }
    private void OnGUI()
    {
        if (GUILayout.Button("关闭场景中所有涉及到的 prefab 的Renderer.allowOcclusionWhenDynamic"))
        {
            Handle();
        }
    }

    private void Handle()
    {
        var scene = EditorSceneManager.GetActiveScene();
        if (!scene.IsValid())
        {
            return;
        }

        handledSetsHelper.Clear();

        var goList = new List<GameObject>();
        // 提取 go
        FilterGOs(scene, goList);

        // 禁止 go 内的 renderer dynamic oc
        var handleRet = DisableDynamicOC(goList);
        switch (handleRet)
        {
            case eDisableRet.Success:
                EditorUtility.DisplayDialog("Disabled Dynamic Occlusion Successfully", "Disabled Dynamic Occlusion Successfully", "OK");
                break;
            case eDisableRet.Cancel:
                Debug.Log("Disabled Dynamic Occlusion was cancel!");
                break;
            case eDisableRet.Error:
                // nops
                break;
            default:
                break;
        }
    }

    private void FilterGOs(Scene scene, List<GameObject> result)
    {
        var firstRootGOs = scene.GetRootGameObjects();
        for (int i = 0; i < firstRootGOs.Length; i++)
        {
            _FilterGOs(firstRootGOs[i], result);
        }
    }

    private void _FilterGOs(GameObject go, List<GameObject> result)
    {
        var status = PrefabUtility.GetPrefabInstanceStatus(go);
        Debug.Log($"go.name : {go.name}, prefab inst status : {status}");
        if (status == PrefabInstanceStatus.NotAPrefab)
        {
            for (int transIDX = 0; transIDX < go.transform.childCount; transIDX++)
            {
                _FilterGOs(go.transform.GetChild(transIDX).gameObject, result);
            }
            return;
        }

        var path = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(go);
        Debug.Log($"go.name : {go.name}, prefab asset path : {path}");
        if (handledSetsHelper.Contains(path))
        {
            Debug.Log($"{path}, renderer.allowOcclusionWhenDynamic = false; was handled, so skipped this time. ");
            return;
        }
        result.Add(go);
    }

    private eDisableRet DisableDynamicOC(List<GameObject> goList)
    {
        try
        {
            var goCount = goList.Count;
            for (int goIDX = 0; goIDX < goCount; goIDX++)
            {
                var cancel = EditorUtility.DisplayCancelableProgressBar("Handling...", $"Handling {goIDX}/{goCount}", (float)goIDX / goCount);
                if (cancel)
                {
                    return eDisableRet.Cancel;
                }

                var go = goList[goIDX];
                var path = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(go);
                if (handledSetsHelper.Contains(path))
                {
                    Debug.Log($"{path}, renderer.allowOcclusionWhenDynamic = false; was handled, so skipped this time. ");
                    continue;
                }

                renderersHelper.Clear();
                go.GetComponentsInChildren<Renderer>(renderersHelper);

                var needToUpdate = false;
                for (int i = 0; i < renderersHelper.Count; i++)
                {
                    var renderer = renderersHelper[i];
                    if (renderer.allowOcclusionWhenDynamic)
                    {
                        renderer.allowOcclusionWhenDynamic = false;
                        needToUpdate = true; // 该标识：只要有一个属性调整了，就整个 prefab apply
                    }
                }
                // 如果需要更新属性才更新 prefab
                if (needToUpdate)
                {
                    //var pmods = PrefabUtility.GetPropertyModifications(go);
                    //PrefabUtility.SetPropertyModifications(go, pmods);
                    PrefabUtility.ApplyPrefabInstance(go, InteractionMode.AutomatedAction);
                    handledSetsHelper.Add(path);
                }
            }
            return eDisableRet.Success;
        }
        catch (Exception er)
        {
            Debug.LogError($"{nameof(DisableRendererOCEditorWindow)}.{nameof(DisableDynamicOC)} error : {er}");
            return eDisableRet.Error;
        }
        finally
        {
            EditorUtility.ClearProgressBar();
        }
    }
}

当场景比较大的时候，这块处理会比较久，因为每一个 Prefab Apply Changes 都是一个文件 IO 的写入操作

通过 AssetPostprocessor 来对导入的资源进行自动禁止动态OC

// jave.lin 2021/08/27
// AssetPostprocessor : https://docs.unity3d.com/ScriptReference/AssetPostprocessor.html
public class AssetImportHandler : AssetPostprocessor
{
    private static List<Renderer> rendererListHelper = new List<Renderer>();
	// 或是 OnPostprocessPrefab 处理也可以 https://docs.unity3d.com/ScriptReference/AssetPostprocessor.OnPostprocessPrefab.html
    void OnPostprocessPrefab(GameObject g)
    {
        Apply(g.transform);
    }

	private static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
	{
		for (int i = 0; i < importedAssets.Length; i++)
        {
            string importedAssetPath = importedAssets[i];
            AssetImporter importer = AssetImporter.GetAtPath(importedAssetPath);
            if (
                // 可以对多个目录下的 prefab 都不要 动态OC
                importedAssetPath.StartsWithFast("Assets/xxx") ||
                importedAssetPath.StartsWithFast("Assets/xxx1") ||
                importedAssetPath.StartsWithFast("Assets/xxx2") ||
                importedAssetPath.StartsWithFast("Assets/xxx3") ||
                importedAssetPath.StartsWithFast("Assets/xxx3")
                )
            {
                if (importedAssetPath.EndsWithFast(".prefab"))
                {
                    // MeshRenderer or SkinnedMeshRenderer 的 dynamicOcclusion 都关闭掉
                    GameObject obj = AssetDatabase.LoadAssetAtPath<GameObject>(importedAssetPath);
                    // mesh renderer
                    rendererListHelper.Clear();
                    obj.GetComponentsInChildren<Renderer>(true, rendererListHelper);
                    var anyChanged = false;
                    foreach (var renderer in rendererListHelper)
                    {
                        if (renderer.allowOcclusionWhenDynamic)
                        {
                            renderer.allowOcclusionWhenDynamic = false;
                            anyChanged = true;
                        }
                    }
                    if (anyChanged)
                    {
                        // jave.lin :经过测试，如果没有 anyChanged 判断的话，会导致无限递归触发 import
                        // unity 也会提示有 auto detect inifinit import 之类的 BUG
                        PrefabUtility.SavePrefabAsset(obj);
                        Debug.Log($"dynamic prefab renderer disabled OC, path : {importedAssetPath}");
                    }
                }
            }
        }
	}
}

对已本身导入到工程的文件，可以右键 Reimport 触发上面代码的机制

新导入的资源会自动触发