NLDClient-yudde/ProjectNLD/Assets/Editor/Scene/PostProcesser/PostProcessor.cs

using System;
using System.Collections.Generic;
using System.Linq;
using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using PhxhSDK.Editor.FileChecker;
using Object = UnityEngine.Object;
using UnityEngine.Timeline;
using Cysharp.Threading.Tasks;
using PhxhSDK;
using UnityEditorGameObjectUtility = UnityEditor.GameObjectUtility;

public abstract class PostProcessor
{
    #region 常量

    /// <summary>
    /// 后处理命名后缀
    /// </summary>
    public const string SCENE_POST_PROCESS_NAME = "PostProcess";

    /// <summary>
    /// 后处理后存放光照贴图和烘焙数据的文件夹命名
    /// </summary>
    private const string LIGHT_BAKE_NAME = "LightMaps";

    /// <summary>
    /// 后处理预制体根路径
    /// </summary>
    protected const string PREFAB_POSTPROCESS_DIR = "Assets/Art_Out/AutoGen/PostProcessPrefabs";

    /// <summary>
    /// 场景资源分组路径 暂时舍弃没有使用Addressable
    /// </summary>
    protected const string SCENE_ADDRESSABLE_GROUP = "PostProcessScenes";

    /// <summary>
    /// 预制体资源分组路径 暂时舍弃没有使用Addressable
    /// </summary>
    protected const string PREFAB_ADDRESSABLE_GROUP = "PostProcessPrefabs";

    /// <summary>
    /// 区分剧情场景的文件夹前缀
    /// </summary>
    private const string STORY_SCENE_PREFIX = "story_";

    /// <summary>
    /// 切割地面贴图宽度
    /// </summary>
    private const int GROUND_SPLIT_WIDTH = 1024;

    /// <summary>
    /// 切割地面贴图高度
    /// </summary>
    private const int GROUND_SPLIT_HEIGHT = 1024;

    /// <summary>
    /// 像素
    /// </summary>
    private const int UPP = 100;

    #endregion

    /// <summary>
    /// 烘焙后需要替换shader的渲染器列表
    /// </summary>
    private readonly List<Renderer> needReplaceRenderers = new();

    /// <summary>
    /// 烘焙后需要关闭产生阴影的渲染器列表
    /// </summary>
    private readonly List<Renderer> allBakeRenderers = new();

    /// <summary>
    /// 实时灯光
    /// </summary>
    private readonly List<Light> realTimeLights = new();

    /// <summary>
    /// 烘焙灯光
    /// </summary>
    private readonly List<Light> bakedLights = new();

    /// <summary>
    /// 检查规范节点
    /// </summary>
    private readonly List<string> sceneRoots = new()
    {
        "Main Camera", "TerrainGridSystem", "Art", "SceneManager", "MapEditor", "LevelEditor", "TGSPreview",
        "InputManager (Singleton)"
    };

    /// <summary>
    /// 需要替换shader烘焙的节点
    /// </summary>
    private readonly List<string> bakeReplaceShaderRoot = new() { "CombinedRoot" };

    /// <summary>
    /// 需要烘焙的其他地面节点
    /// </summary>
    private readonly List<string> groundRoot = new() { "Ground_2" };

    /// <summary>
    /// 后处理文件夹路径 
    /// </summary>
    protected string ProcessedResourceDir => $"{ResourcesBaseDir}/{PostProcessFolderName}";

    protected abstract string PostProcessFolderName { get; }

    protected abstract string ResourcesBaseDir { get; }

    protected abstract Object AssetToPostProcess { get; }

    protected abstract string OutputAssetPath { get; }

    private string LightBakeDir => $"{ProcessedResourceDir}";

    /// <summary>
    /// 是否完成复制场景
    /// </summary>
    private bool HasClone { get; set; }

    /// <summary>
    /// 原始场景路径
    /// </summary>
    private string OriginAssetPath => AssetDatabase.GetAssetPath(AssetToPostProcess);

    protected PostProcessInstructor _processInstructor;

    private PostProcessInstructor _clonedProcessInstructor;

    private PostProcessInstructor PostProcessInstructor => HasClone ? _clonedProcessInstructor : _processInstructor;

    /// <summary>
    /// 用于处理后处理场景中的预制体
    /// </summary>
    private Transform _unpackedCombinedObjectsRoot;

    private Transform CombinedObjectsRoot
    {
        get
        {
            if (_unpackedCombinedObjectsRoot != null && HasClone)
                return _unpackedCombinedObjectsRoot;

            if (PostProcessInstructor == null || PostProcessInstructor.combinedObjectsRoot == null)
            {
                Debug.LogError("找不到Art节点!");
                return PostProcessInstructor.transform.parent;
            }

            return PostProcessInstructor.combinedObjectsRoot;
        }
    }

    protected abstract PostProcessInstructor Clone();

    protected abstract void AfterAll(bool destroyAfterPostProcess);

    protected virtual void Init(PostProcessInstructor postProcessInstructor)
    {
        _processInstructor = postProcessInstructor;
        PostProcessInstructor.DicNumber.Clear();
    }

    public static PostProcessInstructor FindInstructorInScene(Scene scene)
    {
        var instructors = Object.FindObjectsOfType<PostProcessInstructor>();
        return instructors.FirstOrDefault(pi => pi.gameObject.scene == scene);
    }

    #region 后处理多节点

    /// <summary>
    /// 后处理多节点场景 不烘焙 预制体不解包
    /// </summary>
    /// <param name="postProcessInstructors"></param>
    /// <param name="destroyAfterPostProcess"></param>
    public void PostProcessMore(PostProcessInstructor[] postProcessInstructors, bool destroyAfterPostProcess = false)
    {
        if (postProcessInstructors.Length <= 0)
            return;

        var firstPostProcessInstructor = postProcessInstructors[0];
        if (!CheckPostProcessInstructor(firstPostProcessInstructor))
            return;

        Init(firstPostProcessInstructor);
        HasClone = false;
        EditorSceneManager.SaveOpenScenes();

        // 创建文件夹
        AssetDatabase.DeleteAsset(ProcessedResourceDir);
        AssetDatabase.CreateFolder(ResourcesBaseDir, PostProcessFolderName);

        // 复制场景为后处理场景
        Clone();

        // 在后处理场景中重新获取 PostProcessInstructor 组
        PostProcessInstructor[] newPostProcessInstructors = Object.FindObjectsOfType<PostProcessInstructor>();
        int index = 0;
        foreach (PostProcessInstructor postProcessInstructor in newPostProcessInstructors)
        {
            // DebugUtil.LogError($"重新获取的postProcessInstructor属于场景：{postProcessInstructor.gameObject.scene.name}");
            _processInstructor = postProcessInstructor;

            if (PostProcessInstructor == null)
            {
                // DebugUtil.LogError($"PostProcessInstructor为空，克隆参数：{HasClone}");
                continue;
            }

            BakeCombinedGameObject(index);
            ++index;

            if (!PostProcessInstructor.enableSplitGround)
            {
                // 关闭切割地面 给地面添加BoxCollider
                GroundAddBoxCollider();
                ChangeMapTextureAndMatPath();
            }
            else
            {
                SplitGroundTexture();
            }

            SetFogPosition();
            RemoveRedundant();
            HideCamera();
            DestroyUselessObject();
        }

        AfterAll(destroyAfterPostProcess);
        PostProcessData.EditorInstance.AddPostProcessData(AssetToPostProcess, OutputAssetPath);
        Debug.Log($"执行后处理成功，后处理资源源路径:{OriginAssetPath} 后处理后路径:{OutputAssetPath}");
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
    }

    #endregion

    #region 普通后处理

    /// <summary>
    /// 后处理
    /// </summary>
    /// <param name="postProcessInstructor"></param>
    /// <param name="destroyAfterPostProcess"></param>
    /// <param name="defaultCameraParam">是否为默认相机</param>
    public async void PostProcess(PostProcessInstructor postProcessInstructor, bool destroyAfterPostProcess = false,
        bool defaultCameraParam = true)
    {
        if (!CheckPostProcessInstructor(postProcessInstructor))
            return;

        Init(postProcessInstructor);
        HasClone = false;
        EditorSceneManager.SaveOpenScenes();
        PrepareFolders();

        // 复制 ProcessInstructor 组件
        _clonedProcessInstructor = Clone();
        HasClone = true;
        if (_clonedProcessInstructor == null)
        {
            Debug.LogError("_clonedProcessInstructor is null!");
            return;
        }

        GameObject combineRootObj = BakeCombinedGameObject(0);

        _PrepareForBake(combineRootObj.transform);
        await SetTimeline();
        // 如果Art为预制体先进行解包
        UnpackPostSceneArt();

        if(!postProcessInstructor.isTerrain)
        {
            if (!PostProcessInstructor.enableSplitGround)
            {
                // 关闭切割地面 给地面添加BoxCollider
                GroundAddBoxCollider();
                ChangeMapTextureAndMatPath();
            }
            else
            {
                SplitGroundTexture();
            }
        }
        else
        {
            // Terrain 地形处理
            DebugUtil.Log("开始处理 Terrain 地形");
            ChangeMapTextureAndMatPathForTerrain();
        }

        // 根据地面类型选择不同的烘焙方法
        if (PostProcessInstructor.isTerrain)
        {
            BakeLightmapsForTerrain();
        }
        else
        {
            BakeLightmaps();
        }

        SetFogPosition();
        if (!defaultCameraParam)
        {
            SetCameraParam();
        }

        UnpackPostSceneArt();
        RemoveRedundant();
        HideCamera();

        DestroyUselessObject();
        AfterAll(destroyAfterPostProcess);

        PostProcessData.EditorInstance.AddPostProcessData(AssetToPostProcess, OutputAssetPath);
        Debug.Log($"执行后处理成功，后处理资源源路径:{OriginAssetPath} 后处理后路径:{OutputAssetPath}");
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();

        CheckScene();
    }

    #endregion

    private void CheckScene()
    {
        try
        {
            // 获取当前活动的场景
            Scene activeScene = EditorSceneManager.GetActiveScene();
            if (!activeScene.IsValid())
            {
                Debug.LogWarning("[PostProcessor] 当前没有有效的活动场景，跳过场景检查");
                return;
            }

            Debug.Log($"[PostProcessor] 开始检查场景: {activeScene.name}");

            // 获取场景根对象
            GameObject[] rootObjects = activeScene.GetRootGameObjects();
            if (rootObjects == null || rootObjects.Length == 0)
            {
                Debug.LogWarning($"[PostProcessor] 场景 {activeScene.name} 没有根对象，跳过检查");
                return;
            }

            // 获取所有场景文件检查器
            var sceneCheckers = GetAllSceneFileCheckers();
            if (sceneCheckers.Count == 0)
            {
                Debug.LogWarning("[PostProcessor] 没有找到任何场景文件检查器");
                return;
            }

            Debug.Log($"[PostProcessor] 找到 {sceneCheckers.Count} 个场景检查器，开始执行检查...");

            // 执行所有检查器
            bool hasErrors = false;
            List<string> errorMessages = new List<string>();

            foreach (var checker in sceneCheckers)
            {
                try
                {
                    Debug.Log($"[PostProcessor] 执行检查器: {checker.CheckerName}");

                    // 执行检查
                    object checkResult = checker.CheckScene(activeScene, rootObjects);

                    if (checkResult != null)
                    {
                        hasErrors = true;
                        string errorMsg = $"[{checker.CheckerName}] {checkResult}";
                        errorMessages.Add(errorMsg);
                        Debug.LogWarning($"[PostProcessor] 检查失败: {errorMsg}");
                    }
                    else
                    {
                        Debug.Log($"[PostProcessor] 检查器 {checker.CheckerName} 检查通过");
                    }
                }
                catch (System.Exception ex)
                {
                    hasErrors = true;
                    string errorMsg = $"[{checker.CheckerName}] 检查器执行异常: {ex.Message}";
                    errorMessages.Add(errorMsg);
                    Debug.LogError($"[PostProcessor] {errorMsg}");
                }
            }

            // 输出检查结果汇总
            if (hasErrors)
            {
                Debug.LogError($"[PostProcessor] 场景 {activeScene.name} 检查完成，发现 {errorMessages.Count} 个问题:");
                foreach (var errorMsg in errorMessages)
                {
                    Debug.LogError($"[PostProcessor]   • {errorMsg}");
                }
            }
            else
            {
                Debug.Log($"[PostProcessor] 场景 {activeScene.name} 检查完成，所有检查器均通过");
            }
        }
        catch (System.Exception ex)
        {
            Debug.LogError($"[PostProcessor] 场景检查过程中发生异常: {ex.Message}\n{ex.StackTrace}");
        }
    }

    /// <summary>
    /// 获取所有场景文件检查器
    /// </summary>
    private List<BaseSceneFileChecker> GetAllSceneFileCheckers()
    {
        var sceneCheckers = new List<BaseSceneFileChecker>();

        try
        {
            // 获取所有检查器
            var allCheckers = FileCheckerRegistry.Instance.GetAllCheckers();

            // 筛选出场景文件检查器
            foreach (var checker in allCheckers)
            {
                if (checker is BaseSceneFileChecker sceneChecker)
                {
                    sceneCheckers.Add(sceneChecker);
                }
            }
        }
        catch (System.Exception ex)
        {
            Debug.LogError($"[PostProcessor] 获取场景文件检查器时发生异常: {ex.Message}");
        }

        return sceneCheckers;
    }

    private void _PrepareForBake(Transform combineRootParent)
    {
        if (PostProcessInstructor == null || !PostProcessInstructor.enableLightmapBaking)
            return;

        for (var i = 0; i < combineRootParent.childCount; ++i)
        {
            var child = combineRootParent.GetChild(i);
            if (child == null)
                continue;
            var meshRenderer = child.GetComponent<MeshRenderer>();
            if (meshRenderer == null)
            {
                continue;
            }

            if (meshRenderer.shadowCastingMode == ShadowCastingMode.On)
            {
                meshRenderer.shadowCastingMode = ShadowCastingMode.On;
                meshRenderer.staticShadowCaster = true;
                if (meshRenderer.sharedMaterial != null)
                    meshRenderer.sharedMaterial.doubleSidedGI = true;
            }
        }
    }

    private bool CheckPostProcessInstructor(PostProcessInstructor postProcessInstructor)
    {
        if (postProcessInstructor == null)
        {
            Debug.LogError("postProcessInstructor is null");
            return false;
        }

        if (postProcessInstructor.processPrefab &&
            (!PrefabUtility.IsPartOfAnyPrefab(postProcessInstructor) ||
             EditorUtility.IsPersistent(postProcessInstructor)))
        {
            Debug.LogError("postProcessInstructor不在任何预制体内或者其不是预制体实例");
            return false;
        }

        var currentScene = postProcessInstructor.gameObject.scene;
        var objs = currentScene.GetRootGameObjects();
        foreach (var obj in objs)
        {
            if (!sceneRoots.Contains(obj.name))
            {
                Debug.LogWarning($"{currentScene.name} 场景有其他节点:{obj.name}，请检查节点规范");
            }
        }

        return true;
    }

    private void PrepareFolders()
    {
        AssetDatabase.DeleteAsset(ProcessedResourceDir);
        AssetDatabase.CreateFolder(ResourcesBaseDir, PostProcessFolderName);
    }

    /// <summary>
    /// 合并网格、贴图
    /// </summary>
    private GameObject BakeCombinedGameObject(int index)
    {
        Transform art = CombinedObjectsRoot;
        string outputPath = $"{ProcessedResourceDir}";

        // 收集渲染器
        var renderers = MeshCombineUtils.CollectRenderers(PostProcessInstructor.rootsToCombine);
        Debug.Log($"合批前收集到 {renderers.Count} 个渲染器");

        var prefix = GetScenePrefix();
        var combinedRoot = new GameObject("CombinedRoot");
        combinedRoot.transform.parent = art.transform;
        DebugUtil.Log($"合并节点是:{combinedRoot.GetFullPath()},输出路径：{outputPath}，" +
                      $"单位贴图尺寸:{(int)PostProcessInstructor.postProcessTextureUnitSize}");
        try
        {
            if (PostProcessInstructor.enableBatchGrouping)
            {
                var limitRange = MeshCombineUtils.CalculateCurrentHexagonMapBounds(); // 可以根据实际地图调整
                DebugUtil.Log($"边界宽：{limitRange.x},高：{limitRange.y}");
                // 按照距离对渲染器进行分组
                var rendererGroups = MeshCombineUtils.GroupRenderersByProximity(
                    renderers, PostProcessInstructor.batchGroupDistance, limitRange.x, limitRange.y);
                SceneCombineUtil.Instance.CombineGameObjectsByGroups(rendererGroups, combinedRoot.transform,
                    outputPath,
                    (int)PostProcessInstructor.postProcessTextureUnitSize,
                    PostProcessInstructor.sampleMaterials, prefix);
            }
            else
            {
                // 使用原有的合批方式
                SceneCombineUtil.Instance.CombineGameObjects(renderers, combinedRoot.transform, outputPath,
                    (int)PostProcessInstructor.postProcessTextureUnitSize,
                    PostProcessInstructor.sampleMaterials, prefix);
            }

            // 如果是剧情场景，重命名生成的所有物体添加前缀
            if (!string.IsNullOrEmpty(prefix))
            {
                var combined = combinedRoot.GetComponentsInChildren<Transform>();
                foreach (var trans in combined)
                {
                    if (trans != combinedRoot.transform && !trans.name.StartsWith(prefix))
                    {
                        trans.name = prefix + trans.name;
                    }
                }
            }

            foreach (var root in PostProcessInstructor.rootsToCombine)
            {
                if (!root)
                {
                    continue;
                }

                Object.DestroyImmediate(root.gameObject);
            }
        }
        catch (System.Exception ex)
        {
            Debug.LogError($"合批过程中发生错误: {ex.Message}\n{ex.StackTrace}");
            // 如果合批失败，保留原始物体
            if (combinedRoot != null)
            {
                Object.DestroyImmediate(combinedRoot);
            }
        }

        return combinedRoot;
    }

    #region 地面处理

    /// <summary>
    /// 修改地面贴图及材质的路径 用于打包
    /// </summary>
    private void ChangeMapTextureAndMatPath()
    {
        var ground = PostProcessInstructor.ground;
        if (_unpackedCombinedObjectsRoot != null && HasClone)
        {
            ground = _unpackedCombinedObjectsRoot.Find("Ground")?.gameObject;
        }

        GroundUtils.ChangeMapTextureAndMatPath(ground, ProcessedResourceDir, GetScenePrefix(),
            groundRoot, CombinedObjectsRoot, _unpackedCombinedObjectsRoot);
    }

    /// <summary>
    /// 修改Terrain地形贴图及数据的路径 用于打包
    /// </summary>
    private void ChangeMapTextureAndMatPathForTerrain()
    {
        var terrain = PostProcessInstructor.terrain;
        if (terrain == null)
        {
            Debug.LogError("找不到Terrain对象，无法修改Terrain贴图和数据路径");
            return;
        }

        var terrainComponent = terrain.GetComponent<Terrain>();
        if (terrainComponent == null || terrainComponent.terrainData == null)
        {
            Debug.LogError("Terrain对象缺少Terrain组件或TerrainData");
            return;
        }

        var originalTerrainData = terrainComponent.terrainData;
        var originalPath = AssetDatabase.GetAssetPath(originalTerrainData);
        
        if (string.IsNullOrEmpty(originalPath))
        {
            Debug.LogError("无法获取TerrainData的原始路径");
            return;
        }

        // 确保目标目录存在
        if (!AssetDatabase.IsValidFolder(ProcessedResourceDir))
        {
            Debug.LogError($"后处理目录不存在：{ProcessedResourceDir}");
            return;
        }

        // 复制TerrainData到后处理文件夹
        var newTerrainDataPath = $"{ProcessedResourceDir}/{originalTerrainData.name}.asset";
        if (!AssetDatabase.CopyAsset(originalPath, newTerrainDataPath))
        {
            Debug.LogError($"复制TerrainData失败：{originalPath} -> {newTerrainDataPath}");
            return;
        }

        // 加载新的TerrainData
        var newTerrainData = AssetDatabase.LoadAssetAtPath<TerrainData>(newTerrainDataPath);
        if (newTerrainData == null)
        {
            Debug.LogError($"加载新TerrainData失败：{newTerrainDataPath}");
            return;
        }

        // 处理TerrainLayers及其贴图
        var terrainLayers = newTerrainData.terrainLayers;
        var newTerrainLayers = new TerrainLayer[terrainLayers.Length];
        
        for (int i = 0; i < terrainLayers.Length; i++)
        {
            var originalLayer = terrainLayers[i];
            if (originalLayer == null) continue;

            // 为每个 TerrainLayer 创建新的实例并保存到后处理文件夹
            var newLayer = Object.Instantiate(originalLayer);
            
            // 处理贴图并更新新layer的贴图引用为复制后的贴图
            ProcessTerrainLayerTextures(newLayer);
            
            // 创建新的TerrainLayer资产文件路径
            var newLayerPath = $"{ProcessedResourceDir}/{originalLayer.name}_{i}.terrainlayer";
            
            // 保存新的 TerrainLayer 为独立的资产文件
            AssetDatabase.CreateAsset(newLayer, newLayerPath);
            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();
            
            // 重新加载已保存的 TerrainLayer 确保引用正确
            newTerrainLayers[i] = AssetDatabase.LoadAssetAtPath<TerrainLayer>(newLayerPath);
            
            if (newTerrainLayers[i] == null)
            {
                Debug.LogError($"保存TerrainLayer失败：{newLayerPath}");
                newTerrainLayers[i] = originalLayer; // 使用原始引用作为备选
            }
            else
            {
                Debug.Log($"成功创建新的TerrainLayer：{newLayerPath}，使用复制后的贴图");
            }
        }

        // 更新TerrainData的TerrainLayers
        newTerrainData.terrainLayers = newTerrainLayers;

        // 更新Terrain组件的TerrainData引用
        terrainComponent.terrainData = newTerrainData;

        // 同时更新TerrainCollider的TerrainData引用，避免不一致警告
        var terrainCollider = terrain.GetComponent<TerrainCollider>();
        if (terrainCollider != null)
        {
            terrainCollider.terrainData = newTerrainData;
            Debug.Log("已同步更新TerrainCollider的TerrainData引用");
        }

        // 标记场景为脏，确保更改被保存
        EditorSceneManager.MarkSceneDirty(terrain.scene);
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();

        Debug.Log($"Terrain贴图和数据路径修改完成：{newTerrainDataPath}");
    }

    /// <summary>
    /// 处理TerrainLayer中的贴图
    /// </summary>
    private void ProcessTerrainLayerTextures(TerrainLayer terrainLayer)
    {
        if (terrainLayer == null) return;

        // 处理漫反射贴图
        if (terrainLayer.diffuseTexture != null)
        {
            terrainLayer.diffuseTexture = CopyTextureToProcessedDir(terrainLayer.diffuseTexture);
        }

        // 处理法线贴图
        if (terrainLayer.normalMapTexture != null)
        {
            terrainLayer.normalMapTexture = CopyTextureToProcessedDir(terrainLayer.normalMapTexture);
        }

        // 处理遮罩贴图
        if (terrainLayer.maskMapTexture != null)
        {
            terrainLayer.maskMapTexture = CopyTextureToProcessedDir(terrainLayer.maskMapTexture);
        }
    }

    /// <summary>
    /// 复制贴图到后处理目录
    /// </summary>
    private Texture2D CopyTextureToProcessedDir(Texture2D originalTexture)
    {
        if (originalTexture == null) return null;

        var originalPath = AssetDatabase.GetAssetPath(originalTexture);
        if (string.IsNullOrEmpty(originalPath)) return originalTexture;

        var extension = System.IO.Path.GetExtension(originalPath);
        var newTexturePath = $"{ProcessedResourceDir}/{originalTexture.name}{extension}";

        // 如果文件已存在，直接加载返回
        if (AssetDatabase.LoadAssetAtPath<Texture2D>(newTexturePath) != null)
        {
            return AssetDatabase.LoadAssetAtPath<Texture2D>(newTexturePath);
        }

        // 复制贴图文件
        if (AssetDatabase.CopyAsset(originalPath, newTexturePath))
        {
            AssetDatabase.Refresh();
            var newTexture = AssetDatabase.LoadAssetAtPath<Texture2D>(newTexturePath);
            if (newTexture != null)
            {
                Debug.Log($"复制贴图成功：{originalPath} -> {newTexturePath}");
                return newTexture;
            }
        }

        Debug.LogWarning($"复制贴图失败：{originalPath} -> {newTexturePath}");
        return originalTexture; // 返回原始贴图作为备选
    }

    /// <summary>
    /// 给地面添加BoxCollider
    /// </summary>
    private void GroundAddBoxCollider()
    {
        var ground = PostProcessInstructor.ground;
        if (_unpackedCombinedObjectsRoot != null && HasClone)
        {
            ground = _unpackedCombinedObjectsRoot.Find("Ground")?.gameObject;
        }
        
        SceneUtils.RemoveCollider(ground);
        var boxColliderObj = new GameObject("BoxCollider");
        boxColliderObj.layer = LayerMask.NameToLayer(Framework.Constants.Layer.GROUND_NAME);
        SceneUtils.AddBoxCollider(boxColliderObj); 
        boxColliderObj.transform.localScale = new Vector3(300, 300, 1f);
        boxColliderObj.transform.localRotation = Quaternion.Euler(90f, 0f, 0f);
        boxColliderObj.transform.SetParent(PostProcessInstructor.combinedObjectsRoot.transform, false);
        
        // 移除下层地面的碰撞体
        var ground_2 = GameObject.Find("Ground_2");
        SceneUtils.RemoveCollider(ground_2);
    }

    /// <summary>
    /// 切割地面
    /// </summary>
    private void SplitGroundTexture()
    {
        var ground = PostProcessInstructor.ground;
        if (ground == null)
            return;

        GroundUtils.SplitGroundTexture(ground, ProcessedResourceDir, GetScenePrefix(), GROUND_SPLIT_WIDTH,
            GROUND_SPLIT_HEIGHT);
    }

    #endregion

    /// <summary>
    /// 设置雾的位置
    /// </summary>
    private void SetFogPosition()
    {
        SceneUtils.SetFogPosition(PostProcessInstructor.fog);
    }

    /// <summary>
    /// 销毁多余eventSystems
    /// </summary>
    private void RemoveRedundant()
    {
        SceneUtils.RemoveRedundantEventSystems(PostProcessInstructor.gameObject.scene);
    }

    private void DestroyUselessObject()
    {
        foreach (var root in PostProcessInstructor.rootsToCombine)
        {
            if (!root)
            {
                continue;
            }

            Object.DestroyImmediate(root.gameObject, true);
        }

        Object.DestroyImmediate(PostProcessInstructor.gameObject, true);

        var designerObj = GameObject.Find("Designer");
        if (designerObj != null)
        {
            Object.DestroyImmediate(designerObj, true);
        }
    }

    /// <summary>
    /// 检测是否为剧情场景
    /// </summary>
    /// <returns></returns>
    private bool IsStoryScene()
    {
        var sceneName = PostProcessInstructor.gameObject.scene.name;
        return sceneName.Contains(STORY_SCENE_PREFIX);
    }

    private string GetScenePrefix()
    {
        return IsStoryScene() ? STORY_SCENE_PREFIX : "";
    }

    #region 保存相机参数

    private void SetCameraParam()
    {
        var postScene = PostProcessInstructor.gameObject.scene;
        var scene = _processInstructor.gameObject.scene;

        foreach (var rootObj in scene.GetRootGameObjects())
        {
            if (rootObj.CompareTag("MainCamera"))
            {
                CloneCameraToScene(rootObj, postScene);
                break;
            }
        }
    }

    private void CloneCameraToScene(GameObject obj, Scene scene)
    {
        // 只更改transform
        var oldPosition = obj.transform.position;
        var oldRotation = obj.transform.rotation;
        GameObject oldCamera = null;
        foreach (var rootObj in scene.GetRootGameObjects())
        {
            if (rootObj.CompareTag("MainCamera"))
            {
                oldCamera = rootObj;
                break;
            }
        }

        if (oldCamera == null) return;
        oldCamera.transform.position = oldPosition;
        oldCamera.transform.rotation = oldRotation;
    }

    private void HideCamera()
    {
        var scene = PostProcessInstructor.gameObject.scene;
        var cameras = Object.FindObjectsOfType<Camera>();

        foreach (var camera in cameras)
        {
            if (camera.gameObject.scene == scene)
            {
                camera.gameObject.SetActive(false);
                // Debug.Log($"已隐藏相机: {camera.gameObject.name}");
            }
        }

        EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
        EditorSceneManager.SaveOpenScenes();
    }

    #endregion

    #region 烘焙

    /// <summary>
    /// 烘焙灯光贴图的方法
    /// </summary>
    private void BakeLightmaps()
    {
        // 检查是否开启了烘焙选项
        if (PostProcessInstructor == null || !PostProcessInstructor.enableLightmapBaking)
            return;

        Debug.Log("开始灯光烘焙过程...");

        // 1. 从CombinedObjectsRoot下查找灯光 改为烘焙灯光
        LightmapUtils.PrepareLight(CombinedObjectsRoot, realTimeLights, bakedLights);

        // 2. 处理参与烘焙的节点
        LightmapUtils.PreProcessBake(bakeReplaceShaderRoot, CombinedObjectsRoot, true, true, allBakeRenderers,
            needReplaceRenderers);
        LightmapUtils.PreProcessBake(groundRoot, CombinedObjectsRoot, false, false, allBakeRenderers,
            needReplaceRenderers);
        ProcessGround(3000);

        Debug.Log($"总共收集到 {needReplaceRenderers.Count} 个渲染器需要替换shader");
        Debug.Log($"总共收集到 {allBakeRenderers.Count} 个渲染器参与烘焙");

        // 3.替换Shader为支持光照贴图的Shader
        MaterialUtils.ReplaceShaderWithLightmapShader(needReplaceRenderers);

        // 4. 开始烘焙
        LightmapUtils.Bake(SceneManager.GetActiveScene());

        // 5. 关闭所有烘焙物体的阴影投射
        foreach (var renderer in allBakeRenderers)
        {
            if (renderer != null)
                renderer.shadowCastingMode = ShadowCastingMode.Off;
        }

        // 6. 打开实时灯光
        LightmapUtils.RevertLight(realTimeLights, bakedLights);

        // 7.还原地面RenderQueue
        ProcessGround(2000);

        // 8. 复制光照烘焙文件到目标路径
        LightmapUtils.CopyLightmapFiles(SceneManager.GetActiveScene(), LightBakeDir);

        // 9. 保存场景
        EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
        EditorSceneManager.SaveOpenScenes();

        Debug.Log("灯光烘焙处理完成");
    }

    /// <summary>
    /// 专门为Terrain地形烘焙灯光贴图的方法
    /// </summary>
    private void BakeLightmapsForTerrain()
    {
        // 检查是否开启了烘焙选项
        if (PostProcessInstructor == null || !PostProcessInstructor.enableLightmapBaking)
            return;

        Debug.Log("开始Terrain地形灯光烘焙过程...");

        // 1. 从CombinedObjectsRoot下查找灯光 改为烘焙灯光
        LightmapUtils.PrepareLight(CombinedObjectsRoot, realTimeLights, bakedLights);

        // 2. 处理参与烘焙的合批节点（不包括地面）
        LightmapUtils.PreProcessBake(bakeReplaceShaderRoot, CombinedObjectsRoot, true, true, allBakeRenderers,
            needReplaceRenderers);

        // 3. 处理Terrain组件的烘焙设置
        ProcessTerrainForBaking();

        Debug.Log($"总共收集到 {needReplaceRenderers.Count} 个渲染器需要替换shader");
        Debug.Log($"总共收集到 {allBakeRenderers.Count} 个渲染器参与烘焙");

        // 4. 替换Shader为支持光照贴图的Shader（不包括Terrain，Terrain使用内置材质）
        MaterialUtils.ReplaceShaderWithLightmapShader(needReplaceRenderers);

        // 5. 开始烘焙
        LightmapUtils.Bake(SceneManager.GetActiveScene());

        // 6. 关闭所有烘焙物体的阴影投射
        foreach (var renderer in allBakeRenderers)
        {
            if (renderer != null)
                renderer.shadowCastingMode = ShadowCastingMode.Off;
        }

        // 7. 打开实时灯光
        LightmapUtils.RevertLight(realTimeLights, bakedLights);

        // 8. 复制光照烘焙文件到目标路径
        LightmapUtils.CopyLightmapFiles(SceneManager.GetActiveScene(), LightBakeDir);

        // 9. 保存场景
        EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
        EditorSceneManager.SaveOpenScenes();

        Debug.Log("Terrain地形灯光烘焙处理完成");
    }

    /// <summary>
    /// 处理Terrain组件的烘焙设置
    /// </summary>
    private void ProcessTerrainForBaking()
    {
        var terrain = PostProcessInstructor.terrain;
        if (terrain == null)
        {
            Debug.LogWarning("未找到Terrain对象，跳过Terrain烘焙设置");
            return;
        }

        var terrainComponent = terrain.GetComponent<Terrain>();
        if (terrainComponent == null)
        {
            Debug.LogWarning("Terrain对象缺少Terrain组件，跳过Terrain烘焙设置");
            return;
        }

        // 设置Terrain的Static标志，使其参与烘焙
        UnityEditorGameObjectUtility.SetStaticEditorFlags(terrain, StaticEditorFlags.ContributeGI);

        // 获取Terrain的MeshRenderer（如果有的话）
        var terrainRenderer = terrain.GetComponent<MeshRenderer>();
        if (terrainRenderer != null)
        {
            // Terrain通常不使用MeshRenderer，但如果有的话也要处理
            terrainRenderer.shadowCastingMode = ShadowCastingMode.On;
            terrainRenderer.receiveShadows = true;
            allBakeRenderers.Add(terrainRenderer);
            Debug.Log("已将Terrain的MeshRenderer添加到烘焙列表");
        }

        // 设置Terrain的烘焙相关属性
        terrainComponent.shadowCastingMode = ShadowCastingMode.On;

        // 确保TerrainData支持光照贴图
        if (terrainComponent.terrainData != null)
        {
            // Terrain的光照贴图设置通过TerrainData处理
            Debug.Log($"Terrain {terrain.name} 已设置为参与光照烘焙");
        }

        Debug.Log("Terrain烘焙设置完成");
    }

    private void ProcessGround(int renderQueue)
    {
        if (PostProcessInstructor.ground != null)
        {
            SceneUtils.SetGroundRenderQueue(PostProcessInstructor.ground, renderQueue);
        }
    }

    private void UnpackPostSceneArt()
    {
        if (CombinedObjectsRoot != null && PrefabUtility.IsPartOfPrefabInstance(CombinedObjectsRoot.gameObject))
        {
            // 保存对象的引用
            _unpackedCombinedObjectsRoot = CombinedObjectsRoot;
            PhxhSDK.EditorUtils.UnpackPrefab(CombinedObjectsRoot.gameObject);
        }
    }

    #endregion

    #region 剧情Timeline

    /// <summary>
    /// 设置剧情timeline
    /// </summary>
    private UniTask SetTimeline()
    {
        GameObject goOld = PostProcessInstructor.timeline;
        if (null == goOld)
            return UniTask.CompletedTask;

        PlayableDirector oldDirector = goOld.GetComponent<PlayableDirector>();
        if (null == oldDirector)
        {
            Debug.LogError("获取PlayableDirector失败");
            return UniTask.CompletedTask;
        }

        if (null == oldDirector.playableAsset)
        {
            Debug.LogError("获取PlayableAsset失败");
            return UniTask.CompletedTask;
        }

        string oldPath = AssetDatabase.GetAssetPath(oldDirector.playableAsset);
        string newPath = $"{ProcessedResourceDir}/{oldDirector.playableAsset.name}.playable";
        string cmPath = $"{ProcessedResourceDir}/{oldDirector.playableAsset.name}_cinemachine.playable";
        var oldTimelineAsset = oldDirector.playableAsset as TimelineAsset;
        var hasCinemachineTrack = oldTimelineAsset != null && _EnumerateTracks(oldTimelineAsset).Any(_IsCinemachineTrack);
        if (!AssetDatabase.CopyAsset(oldPath, newPath))
        {
            Debug.LogError("Timeline拷贝失败");
            return UniTask.CompletedTask;
        }

        if (hasCinemachineTrack && !AssetDatabase.CopyAsset(oldPath, cmPath))
        {
            Debug.LogError("Cinemachine Timeline拷贝失败");
            return UniTask.CompletedTask;
        }

        var newTimelineAsset = AssetDatabase.LoadAssetAtPath<TimelineAsset>(newPath);
        var cmTimelineAsset = hasCinemachineTrack ? AssetDatabase.LoadAssetAtPath<TimelineAsset>(cmPath) : null;
        if (newTimelineAsset == null || (hasCinemachineTrack && cmTimelineAsset == null))
        {
            Debug.LogError("加载后处理Timeline资源失败");
            return UniTask.CompletedTask;
        }

        _FilterTimelineTracks(newTimelineAsset, keepCinemachine: false);
        if (hasCinemachineTrack)
        {
            _FilterTimelineTracks(cmTimelineAsset, keepCinemachine: true);
        }
        EditorUtility.SetDirty(newTimelineAsset);
        AssetDatabase.SaveAssetIfDirty(newTimelineAsset);
        if (hasCinemachineTrack)
        {
            EditorUtility.SetDirty(cmTimelineAsset);
            AssetDatabase.SaveAssetIfDirty(cmTimelineAsset);
        }

        GameObject goNew = new(goOld.name);
        goNew.transform.parent = goOld.transform.parent;
        goNew.transform.position = Vector3.zero;
        goNew.transform.rotation = Quaternion.identity;
        PlayableDirector newDirector = goNew.AddComponent<PlayableDirector>();
        _CopyDirectorSettings(oldDirector, newDirector);
        newDirector.playableAsset = newTimelineAsset;

        PlayableDirector cmDirector = null;
        if (hasCinemachineTrack)
        {
            GameObject goCm = new("timeline_cinemachine");
            goCm.transform.parent = goOld.transform.parent;
            goCm.transform.position = Vector3.zero;
            goCm.transform.rotation = Quaternion.identity;
            cmDirector = goCm.AddComponent<PlayableDirector>();
            _CopyDirectorSettings(oldDirector, cmDirector);
            cmDirector.playableAsset = cmTimelineAsset;
        }

        _CopyDirectorBindings(oldDirector, newDirector, track => !_IsCinemachineTrack(track));
        if (cmDirector != null)
        {
            _CopyDirectorBindings(oldDirector, cmDirector, _IsCinemachineTrack);
            _SyncExposedReferences(oldDirector, cmDirector);
        }

        GameObject.DestroyImmediate(goOld);

        PostProcessInstructor.timeline = goNew;
        EditorUtility.SetDirty(PostProcessInstructor);
        EditorUtility.SetDirty(newDirector);
        if (cmDirector != null)
        {
            EditorUtility.SetDirty(cmDirector);
        }
        EditorSceneManager.MarkSceneDirty(goNew.scene);

        AssetDatabase.SaveAssetIfDirty(newDirector);
        if (cmDirector != null)
        {
            AssetDatabase.SaveAssetIfDirty(cmDirector);
        }
        return UniTask.CompletedTask;
    }

    private void _CopyDirectorSettings(PlayableDirector oldDirector, PlayableDirector newDirector)
    {
        newDirector.timeUpdateMode = oldDirector.timeUpdateMode;
        newDirector.playOnAwake = oldDirector.playOnAwake;
        newDirector.extrapolationMode = oldDirector.extrapolationMode;
        newDirector.initialTime = oldDirector.initialTime;
    }

    private void _CopyDirectorBindings(PlayableDirector oldDirector, PlayableDirector newDirector, Func<TrackAsset, bool> trackFilter)
    {
        var oldTimelineAsset = oldDirector.playableAsset as TimelineAsset;
        var newTimelineAsset = newDirector.playableAsset as TimelineAsset;
        if (oldTimelineAsset == null || newTimelineAsset == null)
        {
            return;
        }

        var oldTracks = oldTimelineAsset.GetOutputTracks()
            .Where(track => track != null && trackFilter(track))
            .ToList();
        var newTracks = newTimelineAsset.GetOutputTracks()
            .Where(track => track != null)
            .ToList();

        for (int i = 0; i < oldTracks.Count && i < newTracks.Count; ++i)
        {
            var value = oldDirector.GetGenericBinding(oldTracks[i]);
            if (value == null)
            {
                continue;
            }

            newDirector.SetGenericBinding(newTracks[i], value);
        }
    }

    private void _FilterTimelineTracks(TimelineAsset timelineAsset, bool keepCinemachine)
    {
        var allTracks = _EnumerateTracks(timelineAsset).ToList();
        var cmTrackAncestors = new HashSet<TrackAsset>();
        foreach (var track in allTracks.Where(_IsCinemachineTrack))
        {
            for (var current = track; current != null; current = current.parent as TrackAsset)
            {
                cmTrackAncestors.Add(current);
            }
        }

        var removeTracks = allTracks
            .Where(track => keepCinemachine ? !cmTrackAncestors.Contains(track) : _IsCinemachineTrack(track))
            .OrderByDescending(_GetTrackDepth)
            .ToList();

        foreach (var track in removeTracks)
        {
            timelineAsset.DeleteTrack(track);
        }
    }

    private IEnumerable<TrackAsset> _EnumerateTracks(TimelineAsset timelineAsset)
    {
        foreach (var rootTrack in timelineAsset.GetRootTracks())
        {
            if (rootTrack == null)
            {
                continue;
            }

            foreach (var track in _EnumerateTrack(rootTrack))
            {
                yield return track;
            }
        }
    }

    private IEnumerable<TrackAsset> _EnumerateTrack(TrackAsset track)
    {
        yield return track;
        foreach (var childTrack in track.GetChildTracks())
        {
            if (childTrack == null)
            {
                continue;
            }

            foreach (var nestedTrack in _EnumerateTrack(childTrack))
            {
                yield return nestedTrack;
            }
        }
    }

    private int _GetTrackDepth(TrackAsset track)
    {
        var depth = 0;
        for (var parent = track.parent as TrackAsset; parent != null; parent = parent.parent as TrackAsset)
        {
            depth++;
        }

        return depth;
    }

    private bool _IsCinemachineTrack(TrackAsset track)
    {
        return track != null && track.GetType().FullName.Contains("Cinemachine");
    }

    /// <summary>
    /// 同步 Timeline 的 ExposedReferences 到新场景
    /// 主要解决 CinemachineShot 引用的 VirtualCamera 在场景复制后 fileID 变化的问题
    /// </summary>
    private void _SyncExposedReferences(PlayableDirector oldDirector, PlayableDirector newDirector)
    {
        SerializedObject oldDirectorSO = new(oldDirector);
        SerializedProperty oldExposedRefs = oldDirectorSO.FindProperty("m_ExposedReferences.m_References");

        if (oldExposedRefs == null || oldExposedRefs.arraySize == 0)
        {
            Debug.LogWarning("旧 PlayableDirector 没有 ExposedReferences");
            return;
        }

        // 遍历旧的暴露引用，在新场景中找到对应的对象
        for (int i = 0; i < oldExposedRefs.arraySize; ++i)
        {
            SerializedProperty refElement = oldExposedRefs.GetArrayElementAtIndex(i);
            SerializedProperty guidProp = refElement.FindPropertyRelative("first");
            SerializedProperty objProp = refElement.FindPropertyRelative("second");

            if (guidProp == null || objProp == null) continue;

            string exposedName = guidProp.stringValue;
            Object oldReferencedObj = objProp.objectReferenceValue;

            if (string.IsNullOrEmpty(exposedName) || oldReferencedObj == null) continue;

            if (oldReferencedObj is not Component oldComponent)
            {
                continue;
            }

            // 先只处理 Cinemachine 相关轨道，避免误改其他 ExposedReference。
            if (!oldComponent.GetType().FullName.Contains("Cinemachine"))
            {
                continue;
            }

            // 在新场景中找到对应的 GameObject（通过完整路径匹配）
            string oldObjPath = GetGameObjectPath(oldComponent.gameObject);
            GameObject newReferencedObjGo = GameObject.Find(oldObjPath);

            if (newReferencedObjGo == null)
            {
                Debug.LogWarning($"在新场景中找不到对应的 GameObject: {oldObjPath} (exposedName: {exposedName})");
                continue;
            }

            var newReferencedObj = newReferencedObjGo.GetComponent(oldComponent.GetType());
            if (newReferencedObj == null)
            {
                Debug.LogWarning($"在新场景中找不到对应组件: {oldComponent.GetType().FullName}, path: {oldObjPath}, exposedName: {exposedName}");
                continue;
            }

            // 设置新的引用
            newDirector.SetReferenceValue(new PropertyName(exposedName), newReferencedObj);
            Debug.Log($"同步 Cinemachine ExposedReference: {exposedName} -> {oldObjPath} ({oldComponent.GetType().Name})");
        }
    }

    /// <summary>
    /// 获取 GameObject 相对于场景根的完整路径
    /// </summary>
    private string GetGameObjectPath(GameObject go)
    {
        if (go == null) return "";

        var path = go.name;
        Transform parent = go.transform.parent;

        while (parent != null)
        {
            path = parent.name + "/" + path;
            parent = parent.parent;
        }

        return path;
    }
    #endregion
}