using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class CustomPostProcessPass : ScriptableRenderPass
{
    [System.Serializable]
    public class Settings
    {
        public bool active = true;
        public RenderPassEvent renderPassEvent = RenderPassEvent.AfterRenderingPostProcessing;
        public Material material;
        public string shaderName = "Hidden/CustomPostProcess";
        
        [Header("Effect Parameters")]
        public float intensity = 1.0f;
        public float threshold = 0.5f;
        public float softKnee = 0.5f;
        public Color color = Color.white;
        public float blurRadius = 1.0f;
        public int blurIterations = 1;
        public bool useDithering = false;
    }
    
    private Settings m_Settings;
    private ProfilingSampler m_ProfilingSampler;
    private RTHandle m_Source;
    private RTHandle m_Destination;
    private RTHandle m_TemporaryColorTexture;
    private RTHandle m_BlurTexture1;
    private RTHandle m_BlurTexture2;
    
    // 后处理效果的参数ID
    private static readonly int k_SourceTexId = Shader.PropertyToID("_SourceTex");
    private static readonly int k_DestinationTexId = Shader.PropertyToID("_DestinationTex");
    private static readonly int k_IntensityId = Shader.PropertyToID("_Intensity");
    private static readonly int k_ThresholdId = Shader.PropertyToID("_Threshold");
    private static readonly int k_SoftKneeId = Shader.PropertyToID("_SoftKnee");
    private static readonly int k_ColorId = Shader.PropertyToID("_Color");
    private static readonly int k_BlurRadiusId = Shader.PropertyToID("_BlurRadius");
    private static readonly int k_TexelSizeId = Shader.PropertyToID("_TexelSize");
    
    public CustomPostProcessPass(Settings settings)
    {
        m_Settings = settings;
        m_ProfilingSampler = new ProfilingSampler("Custom Post Process Pass");
        
        // 设置渲染事件
        renderPassEvent = settings.renderPassEvent;
    }
    
    public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
    {
        if (!m_Settings.active || m_Settings.material == null)
        {
            return;
        }
        
        // 配置渲染目标
        ConfigureInput(ScriptableRenderPassInput.Color);
    }
    
    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        if (!m_Settings.active || m_Settings.material == null)
        {
            return;
        }
        
        var cmd = CommandBufferPool.Get("Custom Post Process Pass");
        
        using (new ProfilingScope(cmd, m_ProfilingSampler))
        {
            // 获取相机数据
            var cameraData = renderingData.cameraData;
            var source = cameraData.renderer.cameraColorTargetHandle;
            
            // 如果相机使用MSAA，需要先解析到纹理
            if (cameraData.resolveFinalTarget)
            {
                // 创建临时纹理用于处理
                var descriptor = GetRenderTargetDescriptor(cameraData);
                cmd.GetTemporaryRT(k_SourceTexId, descriptor);
                cmd.Blit(source, k_SourceTexId);
                m_Source = RTHandles.Alloc(k_SourceTexId);
            }
            else
            {
                m_Source = source;
            }
            
            // 执行后处理效果
            ExecutePostProcess(cmd, cameraData);
            
            // 如果之前创建了临时纹理，需要复制回原目标
            if (cameraData.resolveFinalTarget)
            {
                cmd.Blit(m_Destination, source);
                cmd.ReleaseTemporaryRT(k_SourceTexId);
            }
        }
        
        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }
    
    private RenderTextureDescriptor GetRenderTargetDescriptor(CameraData cameraData)
    {
        var descriptor = cameraData.cameraTargetDescriptor;
        descriptor.msaaSamples = 1;
        descriptor.volumeDepth = 1;
        descriptor.mipCount = 1;
        descriptor.bounceUsage = RenderTextureSubElement.Color;
        return descriptor;
    }
    
    private void ExecutePostProcess(CommandBuffer cmd, CameraData cameraData)
    {
        // 设置材质参数
        m_Settings.material.SetFloat(k_IntensityId, m_Settings.intensity);
        m_Settings.material.SetFloat(k_ThresholdId, m_Settings.threshold);
        m_Settings.material.SetFloat(k_SoftKneeId, m_Settings.softKnee);
        m_Settings.material.SetColor(k_ColorId, m_Settings.color);
        m_Settings.material.SetFloat(k_BlurRadiusId, m_Settings.blurRadius);
        
        // 获取目标纹理
        var descriptor = cameraData.cameraTargetDescriptor;
        m_Destination = RTHandles.Alloc(
            descriptor.width, 
            descriptor.height, 
            descriptor.colorFormat, 
            descriptor.depthBufferBits, 
            FilterMode.Bilinear, 
            TextureWrapMode.Clamp, 
            1, 
            0, 
            RenderTextureMemoryless.None, 
            descriptor.graphicsFormat, 
            true, 
            false
        );
        
        // 执行后处理效果
        if (m_Settings.blurIterations > 0)
        {
            // 执行模糊效果
            ExecuteBlurEffect(cmd, descriptor);
        }
        else
        {
            // 直接应用效果
            cmd.Blit(m_Source, m_Destination, m_Settings.material);
        }
    }
    
    private void ExecuteBlurEffect(CommandBuffer cmd, RenderTextureDescriptor descriptor)
    {
        // 创建临时纹理用于模糊处理
        var blurDescriptor = descriptor;
        blurDescriptor.width = descriptor.width / 2;  // 降采样以提高性能
        blurDescriptor.height = descriptor.height / 2;
        
        m_BlurTexture1 = RTHandles.Alloc(blurDescriptor);
        m_BlurTexture2 = RTHandles.Alloc(blurDescriptor);
        
        // 降采样源纹理
        cmd.Blit(m_Source, m_BlurTexture1);
        
        // 执行多次模糊迭代
        for (int i = 0; i < m_Settings.blurIterations; i++)
        {
            // 水平模糊
            m_Settings.material.SetVector(k_TexelSizeId, new Vector4(1.0f / m_BlurTexture1.rt.width, 0, 0, 0));
            cmd.Blit(m_BlurTexture1, m_BlurTexture2, m_Settings.material, 0); // 假设Pass 0是水平模糊
            
            // 垂直模糊
            m_Settings.material.SetVector(k_TexelSizeId, new Vector4(0, 1.0f / m_BlurTexture2.rt.height, 0, 0));
            cmd.Blit(m_BlurTexture2, m_BlurTexture1, m_Settings.material, 1); // 假设Pass 1是垂直模糊
        }
        
        // 将模糊结果放大并应用到最终目标
        cmd.Blit(m_BlurTexture1, m_Destination, m_Settings.material, 2); // 假设Pass 2是最终合成
        
        // 释放临时纹理
        m_BlurTexture1?.Release();
        m_BlurTexture2?.Release();
    }
    
    public override void FrameCleanup(CommandBuffer cmd)
    {
        if (m_TemporaryColorTexture != null)
        {
            m_TemporaryColorTexture?.Release();
            m_TemporaryColorTexture = null;
        }
        
        if (m_Destination != null)
        {
            m_Destination?.Release();
            m_Destination = null;
        }
        
        if (m_Source != null && m_Source != RTHandles.CameraTarget)
        {
            m_Source?.Release();
            m_Source = null;
        }
    }
    
    // 获取后处理设置
    public Settings GetSettings()
    {
        return m_Settings;
    }
    
    // 更新后处理参数
    public void UpdateSettings(Settings newSettings)
    {
        m_Settings = newSettings;
    }
    
    // 检查是否激活
    public bool IsActive()
    {
        return m_Settings.active && m_Settings.material != null;
    }
}

// 自定义后处理Feature
public class CustomPostProcessFeature : ScriptableRendererFeature
{
    [System.Serializable]
    public class CustomPostProcessSettings
    {
        public CustomPostProcessPass.Settings passSettings = new CustomPostProcessPass.Settings();
        public RenderPassEvent renderPassEvent = RenderPassEvent.AfterRenderingPostProcessing;
    }
    
    public CustomPostProcessSettings settings = new CustomPostProcessSettings();
    private CustomPostProcessPass m_CustomPostProcessPass;
    
    public override void Create()
    {
        settings.passSettings.renderPassEvent = settings.renderPassEvent;
        
        m_CustomPostProcessPass = new CustomPostProcessPass(settings.passSettings);
        
        // 如果没有提供材质，尝试加载默认材质
        if (settings.passSettings.material == null)
        {
            var shader = Shader.Find(settings.passSettings.shaderName);
            if (shader != null)
            {
                settings.passSettings.material = new Material(shader);
            }
        }
    }
    
    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        if (renderingData.cameraData.postProcessEnabled && m_CustomPostProcessPass.IsActive())
        {
            renderer.EnqueuePass(m_CustomPostProcessPass);
        }
    }
    
    // 更新后处理设置
    public void UpdateSettings(CustomPostProcessPass.Settings newSettings)
    {
        if (m_CustomPostProcessPass != null)
        {
            m_CustomPostProcessPass.UpdateSettings(newSettings);
        }
    }
}

using System;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

// 自定义Volume组件基类
[Serializable, VolumeComponentMenu("Custom/CustomEffect")]
public class CustomEffect : VolumeComponent, IPostProcessComponent
{
    [Tooltip("Controls the overall intensity of the effect.")]
    public ClampedFloatParameter intensity = new ClampedFloatParameter(0f, 0f, 1f);
    
    [Tooltip("Threshold value for the effect.")]
    public ClampedFloatParameter threshold = new ClampedFloatParameter(0.5f, 0f, 1f);
    
    [Tooltip("Soft knee value for smooth transitions.")]
    public ClampedFloatParameter softKnee = new ClampedFloatParameter(0.5f, 0f, 1f);
    
    [Tooltip("Color tint for the effect.")]
    public ColorParameter color = new ColorParameter(Color.white, true, false, true);
    
    [Tooltip("Blur radius for the effect.")]
    public ClampedFloatParameter blurRadius = new ClampedFloatParameter(1.0f, 0f, 10f);
    
    [Tooltip("Number of blur iterations.")]
    public ClampedIntParameter blurIterations = new ClampedIntParameter(1, 0, 5);
    
    [Tooltip("Enable dithering for the effect.")]
    public BoolParameter useDithering = new BoolParameter(false);
    
    public bool IsActive() => intensity.value > 0f;
    
    public bool IsTileCompatible() => false;
}

// Volume系统管理器
public class VolumeSystemManager : MonoBehaviour
{
    [Header("Volume Settings")]
    public bool enableVolumeSystem = true;
    public bool logVolumeData = true;
    
    [Header("Performance Settings")]
    public float volumeUpdateInterval = 0.1f;
    public int maxVolumeQueriesPerFrame = 10;
    public bool enableAsyncVolumeProcessing = true;
    
    private VolumeStack m_GlobalVolumeStack;
    private List<Volume> m_LocalVolumes = new List<Volume>();
    private Dictionary<Camera, VolumeStack> m_CameraVolumeStacks = new Dictionary<Camera, VolumeStack>();
    private float m_LastVolumeUpdate = 0f;
    private int m_VolumeQueriesThisFrame = 0;
    
    [System.Serializable]
    public class VolumeAnalysisData
    {
        public int totalVolumes;
        public int globalVolumes;
        public int localVolumes;
        public int activeComponents;
        public float averageIntensity;
        public float maxDistance;
        public float minDistance;
        public bool hasOverlappingVolumes;
        public System.DateTime lastUpdate;
    }
    
    [System.Serializable]
    public class VolumePerformanceData
    {
        public int volumeQueriesPerSecond;
        public float volumeUpdateTimeMS;
        public int activeVolumeComponents;
        public float memoryUsageKB;
        public bool isOptimal;
    }
    
    public VolumeAnalysisData analysisData = new VolumeAnalysisData();
    public VolumePerformanceData performanceData = new VolumePerformanceData();
    
    void Start()
    {
        if (enableVolumeSystem)
        {
            InitializeVolumeSystem();
        }
    }
    
    void Update()
    {
        if (enableVolumeSystem && Time.time - m_LastVolumeUpdate >= volumeUpdateInterval)
        {
            UpdateVolumeSystem();
            m_LastVolumeUpdate = Time.time;
        }
    }
    
    private void InitializeVolumeSystem()
    {
        // 创建全局Volume Stack
        m_GlobalVolumeStack = VolumeManager.instance.CreateStack();
        
        // 查找场景中的所有Volume
        FindAllVolumes();
        
        if (logVolumeData)
        {
            Debug.Log($"[VolumeSystem] Initialized with {m_LocalVolumes.Count} local volumes");
        }
    }
    
    private void FindAllVolumes()
    {
        m_LocalVolumes.Clear();
        
        // 查找场景中的所有Volume组件
        var volumes = FindObjectsOfType<Volume>();
        foreach (var volume in volumes)
        {
            if (volume != null && volume.profile != null)
            {
                m_LocalVolumes.Add(volume);
            }
        }
        
        // 分析Volume数据
        AnalyzeVolumeData();
    }
    
    private void UpdateVolumeSystem()
    {
        // 更新所有Volume
        UpdateAllVolumes();
        
        // 分析性能数据
        AnalyzePerformanceData();
        
        if (logVolumeData)
        {
            LogVolumePerformance();
        }
    }
    
    private void UpdateAllVolumes()
    {
        m_VolumeQueriesThisFrame = 0;
        
        // 更新相机特定的Volume Stack
        var cameras = FindObjectsOfType<Camera>();
        foreach (var camera in cameras)
        {
            if (camera != null)
            {
                UpdateCameraVolumeStack(camera);
            }
        }
        
        // 重置帧计数
        m_VolumeQueriesThisFrame = 0;
    }
    
    private void UpdateCameraVolumeStack(Camera camera)
    {
        if (!m_CameraVolumeStacks.ContainsKey(camera))
        {
            m_CameraVolumeStacks[camera] = VolumeManager.instance.CreateStack();
        }
        
        var stack = m_CameraVolumeStacks[camera];
        
        // 清空当前Stack
        stack.Reset();
        
        // 添加全局Volume
        var globalVolumes = FindObjectsOfType<Volume>();
        foreach (var volume in globalVolumes)
        {
            if (volume != null && volume.isGlobal)
            {
                stack.AddVolume(volume);
            }
        }
        
        // 添加局部Volume（基于相机位置）
        foreach (var volume in m_LocalVolumes)
        {
            if (volume != null && !volume.isGlobal && IsCameraInVolumeRange(camera, volume))
            {
                stack.AddVolume(volume);
            }
        }
        
        m_VolumeQueriesThisFrame++;
    }
    
    private bool IsCameraInVolumeRange(Camera camera, Volume volume)
    {
        if (volume == null || camera == null) return false;
        
        // 计算相机到Volume的距离
        float distance = Vector3.Distance(camera.transform.position, volume.transform.position);
        
        // 使用Volume的bounds来判断是否在范围内
        var bounds = volume.GetComponent<Collider>()?.bounds;
        if (bounds != null)
        {
            return bounds.Contains(camera.transform.position);
        }
        
        // 如果没有Collider，使用一个默认范围
        return distance < 10.0f; // 默认10单位范围
    }
    
    private void AnalyzeVolumeData()
    {
        analysisData.totalVolumes = m_LocalVolumes.Count;
        analysisData.localVolumes = m_LocalVolumes.Count;
        analysisData.globalVolumes = 0;
        analysisData.activeComponents = 0;
        analysisData.averageIntensity = 0f;
        analysisData.maxDistance = 0f;
        analysisData.minDistance = float.MaxValue;
        analysisData.hasOverlappingVolumes = false;
        analysisData.lastUpdate = System.DateTime.Now;
        
        float intensitySum = 0f;
        
        foreach (var volume in m_LocalVolumes)
        {
            if (volume != null && volume.profile != null)
            {
                // 计算激活的组件数量
                var components = volume.profile.components;
                foreach (var component in components)
                {
                    if (component != null && component.IsActive())
                    {
                        analysisData.activeComponents++;
                    }
                }
                
                // 计算平均强度
                var customEffect = volume.profile.GetComponent<CustomEffect>();
                if (customEffect != null)
                {
                    intensitySum += customEffect.intensity.value;
                }
            }
        }
        
        if (analysisData.activeComponents > 0)
        {
            analysisData.averageIntensity = intensitySum / analysisData.activeComponents;
        }
        
        // 检查是否有重叠的Volume
        for (int i = 0; i < m_LocalVolumes.Count; i++)
        {
            for (int j = i + 1; j < m_LocalVolumes.Count; j++)
            {
                if (DoVolumesOverlap(m_LocalVolumes[i], m_LocalVolumes[j]))
                {
                    analysisData.hasOverlappingVolumes = true;
                    break;
                }
            }
            if (analysisData.hasOverlappingVolumes) break;
        }
    }
    
    private bool DoVolumesOverlap(Volume volume1, Volume volume2)
    {
        if (volume1 == null || volume2 == null) return false;
        
        var collider1 = volume1.GetComponent<Collider>();
        var collider2 = volume2.GetComponent<Collider>();
        
        if (collider1 != null && collider2 != null)
        {
            // 简化的重叠检测
            var bounds1 = collider1.bounds;
            var bounds2 = collider2.bounds;
            
            return bounds1.Intersects(bounds2);
        }
        
        return false;
    }
    
    private void AnalyzePerformanceData()
    {
        performanceData.volumeQueriesPerSecond = Mathf.RoundToInt(analysisData.totalVolumes / volumeUpdateInterval);
        performanceData.activeVolumeComponents = analysisData.activeComponents;
        performanceData.memoryUsageKB = analysisData.totalVolumes * 4; // 简化估算
        performanceData.isOptimal = performanceData.volumeQueriesPerSecond < 100; // 假设阈值
    }
    
    private void LogVolumePerformance()
    {
        var log = new System.Text.StringBuilder();
        log.AppendLine("=== Volume System Performance ===");
        log.AppendLine($"Total Volumes: {analysisData.totalVolumes}");
        log.AppendLine($"Active Components: {analysisData.activeComponents}");
        log.AppendLine($"Average Intensity: {analysisData.averageIntensity:F3}");
        log.AppendLine($"Has Overlapping: {analysisData.hasOverlappingVolumes}");
        log.AppendLine($"Volume Queries/s: {performanceData.volumeQueriesPerSecond}");
        log.AppendLine($"Memory Usage: {performanceData.memoryUsageKB:F1} KB");
        log.AppendLine($"Is Optimal: {performanceData.isOptimal}");
        
        Debug.Log(log.ToString());
    }
    
    // 获取当前相机的Volume Stack
    public VolumeStack GetVolumeStackForCamera(Camera camera)
    {
        if (m_CameraVolumeStacks.ContainsKey(camera))
        {
            return m_CameraVolumeStacks[camera];
        }
        
        return m_GlobalVolumeStack;
    }
    
    // 获取Volume分析数据
    public VolumeAnalysisData GetVolumeAnalysisData()
    {
        return analysisData;
    }
    
    // 获取Volume性能数据
    public VolumePerformanceData GetVolumePerformanceData()
    {
        return performanceData;
    }
    
    // 手动添加Volume到系统
    public void AddVolume(Volume volume)
    {
        if (volume != null && !m_LocalVolumes.Contains(volume))
        {
            m_LocalVolumes.Add(volume);
            AnalyzeVolumeData();
        }
    }
    
    // 手动移除Volume
    public void RemoveVolume(Volume volume)
    {
        if (volume != null)
        {
            m_LocalVolumes.Remove(volume);
            AnalyzeVolumeData();
        }
    }
    
    // 更新Volume参数
    public void UpdateVolumeParameters(Volume volume, float intensity, float threshold, Color color)
    {
        if (volume != null && volume.profile != null)
        {
            var customEffect = volume.profile.GetComponent<CustomEffect>();
            if (customEffect != null)
            {
                customEffect.intensity.value = intensity;
                customEffect.threshold.value = threshold;
                customEffect.color.value = color;
            }
        }
    }
    
    // 获取所有Volume列表
    public List<Volume> GetAllVolumes()
    {
        return new List<Volume>(m_LocalVolumes);
    }
    
    // 获取激活的Volume组件数量
    public int GetActiveVolumeComponentsCount()
    {
        return analysisData.activeComponents;
    }
    
    // 获取Volume统计信息
    public string GetVolumeStats()
    {
        var stats = new System.Text.StringBuilder();
        stats.AppendLine("=== Volume Statistics ===");
        stats.AppendLine($"Total Volumes: {analysisData.totalVolumes}");
        stats.AppendLine($"Global Volumes: {analysisData.globalVolumes}");
        stats.AppendLine($"Local Volumes: {analysisData.localVolumes}");
        stats.AppendLine($"Active Components: {analysisData.activeComponents}");
        stats.AppendLine($"Average Intensity: {analysisData.averageIntensity:F3}");
        stats.AppendLine($"Has Overlaps: {analysisData.hasOverlappingVolumes}");
        stats.AppendLine($"Last Update: {analysisData.lastUpdate}");
        
        return stats.ToString();
    }
    
    void OnDestroy()
    {
        // 清理Volume Stack
        if (m_GlobalVolumeStack != null)
        {
            VolumeManager.instance.DestroyStack(m_GlobalVolumeStack);
        }
        
        foreach (var kvp in m_CameraVolumeStacks)
        {
            if (kvp.Value != null)
            {
                VolumeManager.instance.DestroyStack(kvp.Value);
            }
        }
        
        m_CameraVolumeStacks.Clear();
    }
}

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class PostProcessResourceManager : MonoBehaviour
{
    [Header("Resource Management Settings")]
    public bool enableResourceManagement = true;
    public bool enableTexturePooling = true;
    public bool enableAsyncRelease = true;
    public bool logResourceData = true;
    
    [Header("Pool Configuration")]
    public int initialPoolSize = 4;
    public int maxPoolSize = 16;
    public float textureLifetime = 5.0f;
    public float cleanupInterval = 1.0f;
    
    [Header("Memory Settings")]
    public float memoryBudgetMB = 256.0f;
    public float memoryWarningThreshold = 0.8f;
    public bool enableMemoryOptimization = true;
    
    private Dictionary<string, Queue<RTHandle>> m_TexturePool = new Dictionary<string, Queue<RTHandle>>();
    private Dictionary<RTHandle, float> m_TextureUsageTime = new Dictionary<RTHandle, float>();
    private List<RTHandle> m_ActiveTextures = new List<RTHandle>();
    private float m_LastCleanup = 0f;
    private float m_CurrentMemoryUsage = 0f;
    
    [System.Serializable]
    public class ResourceAnalysisData
    {
        public int pooledTextures;
        public int activeTextures;
        public int totalTextures;
        public float memoryUsageMB;
        public float memoryBudgetMB;
        public float memoryUsagePercentage;
        public int texturesInUse;
        public int texturesInPool;
        public float averageTextureLifetime;
        public bool memoryBudgetExceeded;
        public System.DateTime lastUpdate;
    }
    
    [System.Serializable]
    public class ResourcePerformanceData
    {
        public int allocationCount;
        public int deallocationCount;
        public int poolHitCount;
        public int poolMissCount;
        public float poolHitRate;
        public float allocationTimeMS;
        public float deallocationTimeMS;
        public bool isOptimal;
    }
    
    public ResourceAnalysisData analysisData = new ResourceAnalysisData();
    public ResourcePerformanceData performanceData = new ResourcePerformanceData();
    
    void Start()
    {
        if (enableResourceManagement)
        {
            InitializeResourceManagement();
        }
    }
    
    void Update()
    {
        if (enableResourceManagement && Time.time - m_LastCleanup >= cleanupInterval)
        {
            CleanupUnusedResources();
            m_LastCleanup = Time.time;
        }
    }
    
    private void InitializeResourceManagement()
    {
        // 初始化纹理池
        InitializeTexturePools();
        
        if (logResourceData)
        {
            Debug.Log("[PostProcessResourceManager] Initialized resource management system");
        }
    }
    
    private void InitializeTexturePools()
    {
        // 预创建一些常用尺寸的纹理
        var commonSizes = new[]
        {
            new Vector2Int(256, 256),
            new Vector2Int(512, 512),
            new Vector2Int(1024, 1024),
            new Vector2Int(2048, 2048)
        };
        
        foreach (var size in commonSizes)
        {
            string poolKey = GetTexturePoolKey(size.x, size.y, RenderTextureFormat.ARGB32);
            if (!m_TexturePool.ContainsKey(poolKey))
            {
                m_TexturePool[poolKey] = new Queue<RTHandle>();
                
                // 预分配一些纹理到池中
                for (int i = 0; i < initialPoolSize; i++)
                {
                    var texture = CreateTexture(size.x, size.y, RenderTextureFormat.ARGB32);
                    if (texture != null)
                    {
                        m_TexturePool[poolKey].Enqueue(texture);
                        m_CurrentMemoryUsage += CalculateTextureMemory(size.x, size.y, RenderTextureFormat.ARGB32);
                    }
                }
            }
        }
        
        UpdateAnalysisData();
    }
    
    private string GetTexturePoolKey(int width, int height, RenderTextureFormat format)
    {
        return $"{width}x{height}_{format}";
    }
    
    private RTHandle CreateTexture(int width, int height, RenderTextureFormat format)
    {
        try
        {
            var descriptor = new RenderTextureDescriptor
            {
                width = width,
                height = height,
                colorFormat = format,
                depthBufferBits = 0,
                msaaSamples = 1,
                volumeDepth = 1,
                mipCount = 1,
                enableRandomWrite = false,
                useMipMap = false,
                autoGenerateMips = false,
                sRGB = false
            };
            
            return RTHandles.Alloc(descriptor);
        }
        catch (System.Exception ex)
        {
            if (logResourceData)
            {
                Debug.LogError($"[PostProcessResourceManager] Failed to create texture: {ex.Message}");
            }
            return null;
        }
    }
    
    private float CalculateTextureMemory(int width, int height, RenderTextureFormat format)
    {
        int bytesPerPixel = GetFormatBytes(format);
        int totalBytes = width * height * bytesPerPixel;
        return totalBytes / (1024.0f * 1024.0f); // 转换为MB
    }
    
    private int GetFormatBytes(RenderTextureFormat format)
    {
        switch (format)
        {
            case RenderTextureFormat.ARGB32:
            case RenderTextureFormat.RGB111110Float:
                return 4;
            case RenderTextureFormat.ARGBHalf:
            case RenderTextureFormat.Depth:
                return 2;
            case RenderTextureFormat.ARGBFloat:
                return 16;
            default:
                return 4; // 默认值
        }
    }
    
    // 从池中获取纹理
    public RTHandle GetTexture(int width, int height, RenderTextureFormat format = RenderTextureFormat.ARGB32)
    {
        string poolKey = GetTexturePoolKey(width, height, format);
        RTHandle texture = null;
        
        if (enableTexturePooling && m_TexturePool.ContainsKey(poolKey) && m_TexturePool[poolKey].Count > 0)
        {
            // 从池中取出纹理
            texture = m_TexturePool[poolKey].Dequeue();
            performanceData.poolHitCount++;
        }
        else
        {
            // 创建新纹理
            texture = CreateTexture(width, height, format);
            performanceData.poolMissCount++;
            
            if (texture != null)
            {
                m_CurrentMemoryUsage += CalculateTextureMemory(width, height, format);
            }
        }
        
        performanceData.allocationCount++;
        
        if (texture != null)
        {
            m_ActiveTextures.Add(texture);
            m_TextureUsageTime[texture] = Time.time;
        }
        
        if (logResourceData && texture == null)
        {
            Debug.LogWarning($"[PostProcessResourceManager] Failed to get texture: {width}x{height}, Format: {format}");
        }
        
        UpdateAnalysisData();
        return texture;
    }
    
    // 释放纹理回池
    public void ReleaseTexture(RTHandle texture)
    {
        if (texture == null) return;
        
        // 从活动列表中移除
        m_ActiveTextures.Remove(texture);
        m_TextureUsageTime.Remove(texture);
        
        // 计算释放的内存
        var desc = texture.rt.descriptor;
        float releasedMemory = CalculateTextureMemory(desc.width, desc.height, desc.colorFormat);
        m_CurrentMemoryUsage -= releasedMemory;
        
        if (enableTexturePooling)
        {
            // 尝试找到合适的池
            string poolKey = GetTexturePoolKey(desc.width, desc.height, desc.colorFormat);
            
            if (!m_TexturePool.ContainsKey(poolKey))
            {
                m_TexturePool[poolKey] = new Queue<RTHandle>();
            }
            
            // 检查池大小限制
            if (m_TexturePool[poolKey].Count < maxPoolSize)
            {
                m_TexturePool[poolKey].Enqueue(texture);
            }
            else
            {
                // 池已满，直接释放纹理
                if (enableAsyncRelease)
                {
                    StartCoroutine(AsyncReleaseTexture(texture));
                }
                else
                {
                    texture?.Release();
                }
            }
        }
        else
        {
            // 不使用池，直接释放
            if (enableAsyncRelease)
            {
                StartCoroutine(AsyncReleaseTexture(texture));
            }
            else
            {
                texture?.Release();
            }
        }
        
        performanceData.deallocationCount++;
        UpdateAnalysisData();
    }
    
    private System.Collections.IEnumerator AsyncReleaseTexture(RTHandle texture)
    {
        yield return new WaitForEndOfFrame();
        texture?.Release();
    }
    
    // 清理未使用的资源
    private void CleanupUnusedResources()
    {
        var texturesToRelease = new List<RTHandle>();
        
        // 查找超时的纹理
        foreach (var kvp in m_TextureUsageTime)
        {
            if (Time.time - kvp.Value > textureLifetime)
            {
                texturesToRelease.Add(kvp.Key);
            }
        }
        
        // 释放超时的纹理
        foreach (var texture in texturesToRelease)
        {
            if (m_ActiveTextures.Contains(texture))
            {
                ReleaseTexture(texture);
            }
        }
        
        // 如果内存使用超过预算，执行内存优化
        if (m_CurrentMemoryUsage > memoryBudgetMB * memoryWarningThreshold && enableMemoryOptimization)
        {
            OptimizeMemoryUsage();
        }
        
        UpdateAnalysisData();
    }
    
    private void OptimizeMemoryUsage()
    {
        // 清空纹理池以释放内存
        foreach (var pool in m_TexturePool.Values)
        {
            while (pool.Count > 0)
            {
                var texture = pool.Dequeue();
                texture?.Release();
                m_CurrentMemoryUsage -= CalculateTextureMemory(
                    texture.rt.descriptor.width, 
                    texture.rt.descriptor.height, 
                    texture.rt.descriptor.colorFormat);
            }
        }
        
        if (logResourceData)
        {
            Debug.LogWarning($"[PostProcessResourceManager] Memory optimization performed. Current usage: {m_CurrentMemoryUsage:F2}MB");
        }
    }
    
    private void UpdateAnalysisData()
    {
        analysisData.pooledTextures = 0;
        analysisData.activeTextures = m_ActiveTextures.Count;
        
        foreach (var pool in m_TexturePool.Values)
        {
            analysisData.pooledTextures += pool.Count;
        }
        
        analysisData.totalTextures = analysisData.pooledTextures + analysisData.activeTextures;
        analysisData.memoryUsageMB = m_CurrentMemoryUsage;
        analysisData.memoryBudgetMB = memoryBudgetMB;
        analysisData.memoryUsagePercentage = (m_CurrentMemoryUsage / memoryBudgetMB) * 100f;
        analysisData.texturesInUse = analysisData.activeTextures;
        analysisData.texturesInPool = analysisData.pooledTextures;
        analysisData.memoryBudgetExceeded = m_CurrentMemoryUsage > memoryBudgetMB;
        analysisData.lastUpdate = System.DateTime.Now;
        
        // 计算平均纹理生命周期
        float totalLifetime = 0f;
        int count = 0;
        foreach (var kvp in m_TextureUsageTime)
        {
            totalLifetime += Time.time - kvp.Value;
            count++;
        }
        analysisData.averageTextureLifetime = count > 0 ? totalLifetime / count : 0f;
        
        // 更新性能数据
        performanceData.poolHitRate = performanceData.allocationCount > 0 ? 
            (float)performanceData.poolHitCount / performanceData.allocationCount : 0f;
        performanceData.isOptimal = performanceData.poolHitRate > 0.7f; // 假设70%命中率是理想的
    }
    
    // 获取资源分析数据
    public ResourceAnalysisData GetResourceAnalysisData()
    {
        return analysisData;
    }
    
    // 获取资源性能数据
    public ResourcePerformanceData GetResourcePerformanceData()
    {
        return performanceData;
    }
    
    // 获取纹理池统计
    public string GetTexturePoolStats()
    {
        var stats = new System.Text.StringBuilder();
        stats.AppendLine("=== Texture Pool Statistics ===");
        
        foreach (var kvp in m_TexturePool)
        {
            stats.AppendLine($"{kvp.Key}: {kvp.Value.Count} textures in pool");
        }
        
        stats.AppendLine($"Active Textures: {analysisData.activeTextures}");
        stats.AppendLine($"Pooled Textures: {analysisData.pooledTextures}");
        stats.AppendLine($"Total Memory: {analysisData.memoryUsageMB:F2} MB");
        stats.AppendLine($"Pool Hit Rate: {performanceData.poolHitRate:F2}");
        
        return stats.ToString();
    }
    
    // 获取资源统计信息
    public string GetResourceStats()
    {
        var stats = new System.Text.StringBuilder();
        stats.AppendLine("=== Resource Statistics ===");
        stats.AppendLine($"Total Textures: {analysisData.totalTextures}");
        stats.AppendLine($"Active Textures: {analysisData.activeTextures}");
        stats.AppendLine($"Pooled Textures: {analysisData.pooledTextures}");
        stats.AppendLine($"Memory Usage: {analysisData.memoryUsageMB:F2} MB / {analysisData.memoryBudgetMB:F2} MB");
        stats.AppendLine($"Memory Usage: {analysisData.memoryUsagePercentage:F1}%");
        stats.AppendLine($"Pool Hit Rate: {performanceData.poolHitRate:F2}");
        stats.AppendLine($"Allocation Count: {performanceData.allocationCount}");
        stats.AppendLine($"Deallocation Count: {performanceData.deallocationCount}");
        stats.AppendLine($"Is Memory Budget Exceeded: {analysisData.memoryBudgetExceeded}");
        stats.AppendLine($"Is Optimal: {performanceData.isOptimal}");
        
        return stats.ToString();
    }
    
    // 强制清理所有资源
    public void ForceCleanupAllResources()
    {
        // 释放所有活动纹理
        foreach (var texture in m_ActiveTextures)
        {
            texture?.Release();
        }
        m_ActiveTextures.Clear();
        m_TextureUsageTime.Clear();
        
        // 清空纹理池
        foreach (var pool in m_TexturePool.Values)
        {
            while (pool.Count > 0)
            {
                var texture = pool.Dequeue();
                texture?.Release();
            }
        }
        
        m_CurrentMemoryUsage = 0f;
        
        if (logResourceData)
        {
            Debug.Log("[PostProcessResourceManager] All resources cleaned up");
        }
    }
    
    // 获取当前内存使用情况
    public float GetCurrentMemoryUsage()
    {
        return m_CurrentMemoryUsage;
    }
    
    // 获取内存预算
    public float GetMemoryBudget()
    {
        return memoryBudgetMB;
    }
    
    // 检查内存是否超预算
    public bool IsMemoryBudgetExceeded()
    {
        return analysisData.memoryBudgetExceeded;
    }
    
    void OnDestroy()
    {
        ForceCleanupAllResources();
    }
}