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

public class ScreenSpaceReflectionPass : ScriptableRenderPass
{
    private static readonly string k_RenderTag = "Screen Space Reflection Pass";
    private static readonly int k_SSRSourceTextureId = Shader.PropertyToID("_SSRSourceTexture");
    private static readonly int k_SSRSourceTexture2Id = Shader.PropertyToID("_SSRSourceTexture2");
    private static readonly int k_CameraDepthTextureId = Shader.PropertyToID("_CameraDepthTexture");
    private static readonly int k_CameraOpaqueTextureId = Shader.PropertyToID("_CameraOpaqueTexture");
    private static readonly int k_SSRResultId = Shader.PropertyToID("_SSRResult");
    
    private Material m_SSRMaterial;
    private RTHandle m_SSRResult;
    
    public ScreenSpaceReflectionPass(RenderPassEvent evt, Material material)
    {
        renderPassEvent = evt;
        m_SSRMaterial = material;
    }
    
    public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
    {
        var descriptor = cameraTextureDescriptor;
        descriptor.depthBufferBits = 0;
        
        // 创建SSR结果纹理
        RenderingUtils.ReAllocateIfNeeded(ref m_SSRResult, descriptor, 
            name: k_SSRResultId);
        
        ConfigureTarget(m_SSRResult);
        ConfigureClear(ClearFlag.Color, Color.clear);
    }
    
    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        if (m_SSRMaterial == null)
            return;
            
        CommandBuffer cmd = CommandBufferPool.Get(k_RenderTag);
        
        RenderTextureDescriptor opaqueDescriptor = renderingData.cameraData.cameraTargetDescriptor;
        opaqueDescriptor.depthBufferBits = 0;
        
        // 获取深度和颜色纹理
        cmd.GetTemporaryRT(k_CameraDepthTextureId, opaqueDescriptor);
        cmd.GetTemporaryRT(k_CameraOpaqueTextureId, opaqueDescriptor);
        
        // 执行SSR计算
        ExecuteSSR(cmd, renderingData);
        
        cmd.ReleaseTemporaryRT(k_CameraDepthTextureId);
        cmd.ReleaseTemporaryRT(k_CameraOpaqueTextureId);
        
        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }
    
    private void ExecuteSSR(CommandBuffer cmd, RenderingData renderingData)
    {
        // 设置SSR参数
        m_SSRMaterial.SetMatrix("_ViewProjectionMatrix", 
            renderingData.cameraData.GetViewProjectionMatrix());
        m_SSRMaterial.SetMatrix("_InverseViewProjectionMatrix", 
            renderingData.cameraData.GetViewProjectionMatrix().inverse);
        m_SSRMaterial.SetVector("_ScreenParams", 
            new Vector4(Screen.width, Screen.height, 1.0f / Screen.width, 1.0f / Screen.height));
        
        // 执行SSR追踪
        cmd.Blit(m_SSRResult, m_SSRResult, m_SSRMaterial, 0);
    }
    
    public override void FrameCleanup(CommandBuffer cmd)
    {
        if (m_SSRResult != null)
            m_SSRResult?.Release();
    }
    
    public RTHandle GetSSRResult()
    {
        return m_SSRResult;
    }
}

public class ScreenSpaceReflectionFeature : ScriptableRendererFeature
{
    [System.Serializable]
    public class SSRSettings
    {
        public Material SSRMaterial;
        public RenderPassEvent Event = RenderPassEvent.BeforeRenderingPostProcessing;
        [Range(0.1f, 2.0f)] public float MaxDistance = 100.0f;
        [Range(1, 64)] public int MaxSteps = 32;
        [Range(0.001f, 0.1f)] public float Thickness = 0.01f;
        [Range(0.0f, 1.0f)] public float ReflectionIntensity = 1.0f;
    }
    
    public SSRSettings settings = new SSRSettings();
    private ScreenSpaceReflectionPass m_SSRPass;
    
    public override void Create()
    {
        if (settings.SSRMaterial == null)
        {
            Debug.LogError("SSR Material is not assigned!");
            return;
        }
        
        m_SSRPass = new ScreenSpaceReflectionPass(settings.Event, settings.SSRMaterial);
    }
    
    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        if (settings.SSRMaterial != null)
        {
            renderer.EnqueuePass(m_SSRPass);
        }
    }
}

// SSR着色器代码（简化版）
/*
Shader "URP/ScreenSpaceReflection"
{
    Properties
    {
        _MainTex ("Screen Texture", 2D) = "white" {}
        _DepthTex ("Depth Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" }
        
        Pass
        {
            Name "SSR"
            ZTest Always
            ZWrite Off
            Cull Off
            
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE
            #pragma multi_compile _ _SHADOWS_SOFT
            
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            
            struct Attributes
            {
                float4 positionOS : POSITION;
                float2 uv : TEXCOORD0;
            };
            
            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 positionNDC : TEXCOORD1;
            };
            
            TEXTURE2D(_MainTex);    SAMPLER(sampler_MainTex);
            TEXTURE2D(_CameraDepthTexture);    SAMPLER(sampler_CameraDepthTexture);
            
            uniform float4x4 _ViewProjectionMatrix;
            uniform float4x4 _InverseViewProjectionMatrix;
            uniform float4 _ScreenParams;
            uniform float _MaxDistance;
            uniform int _MaxSteps;
            uniform float _Thickness;
            uniform float _ReflectionIntensity;
            
            Varyings vert(Attributes input)
            {
                Varyings output;
                output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
                output.uv = input.uv;
                output.positionNDC = output.positionCS / output.positionCS.w;
                return output;
            }
            
            float4 frag(Varyings input) : SV_Target
            {
                float2 uv = input.uv;
                
                // 获取深度信息
                float depth = SAMPLE_TEXTURE2D(_CameraDepthTexture, sampler_CameraDepthTexture, uv).r;
                float3 viewPos = ComputeViewSpacePosition(uv, depth, _InverseViewProjectionMatrix);
                float3 worldPos = mul(unity_CameraToWorld, float4(viewPos, 1.0)).xyz;
                float3 viewDir = normalize(viewPos);
                
                // 计算反射方向
                float3 normal = ComputeScreenSpaceNormal(uv); // 需要法线纹理
                float3 reflectDir = reflect(-viewDir, normal);
                
                // 屏幕空间追踪
                float3 rayPos = viewPos;
                float stepSize = _MaxDistance / _MaxSteps;
                
                for (int i = 0; i < _MaxSteps; i++)
                {
                    rayPos += reflectDir * stepSize;
                    
                    // 转换到屏幕空间
                    float4 projectedPos = mul(_ViewProjectionMatrix, float4(rayPos, 1.0));
                    float2 screenUV = projectedPos.xy / projectedPos.w * 0.5 + 0.5;
                    
                    if (screenUV.x < 0 || screenUV.x > 1 || screenUV.y < 0 || screenUV.y > 1)
                        break;
                    
                    // 检查深度差异
                    float sampledDepth = SAMPLE_TEXTURE2D(_CameraDepthTexture, sampler_CameraDepthTexture, screenUV).r;
                    float3 sampledViewPos = ComputeViewSpacePosition(screenUV, sampledDepth, _InverseViewProjectionMatrix);
                    
                    if (abs(rayPos.z - sampledViewPos.z) < _Thickness)
                    {
                        // 找到交点，采样颜色
                        float4 reflectedColor = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, screenUV);
                        float4 originalColor = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
                        
                        return lerp(originalColor, reflectedColor, _ReflectionIntensity);
                    }
                }
                
                return SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
            }
            ENDHLSL
        }
    }
}
*/

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

public class TemporalAAPass : ScriptableRenderPass
{
    private static readonly string k_RenderTag = "Temporal AA Pass";
    private static readonly int k_CurrentColorTextureId = Shader.PropertyToID("_CurrentColorTexture");
    private static readonly int k_HistoryColorTextureId = Shader.PropertyToID("_HistoryColorTexture");
    private static readonly int k_MotionVectorTextureId = Shader.PropertyToID("_MotionVectorTexture");
    private static readonly int k_TAAOutputTextureId = Shader.PropertyToID("_TAAOutputTexture");
    
    private Material m_TAAMaterial;
    private RTHandle m_HistoryTexture;
    private RTHandle m_CurrentTexture;
    private RTHandle m_OutputTexture;
    
    private Matrix4x4 m_PreviousViewProjectionMatrix;
    private bool m_FirstFrame = true;
    
    public TemporalAAPass(RenderPassEvent evt, Material material)
    {
        renderPassEvent = evt;
        m_TAAMaterial = material;
    }
    
    public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
    {
        var descriptor = cameraTextureDescriptor;
        descriptor.depthBufferBits = 0;
        
        // 创建纹理
        RenderingUtils.ReAllocateIfNeeded(ref m_HistoryTexture, descriptor, 
            name: k_HistoryColorTextureId);
        RenderingUtils.ReAllocateIfNeeded(ref m_CurrentTexture, descriptor, 
            name: k_CurrentColorTextureId);
        RenderingUtils.ReAllocateIfNeeded(ref m_OutputTexture, descriptor, 
            name: k_TAAOutputTextureId);
        
        ConfigureTarget(m_OutputTexture);
        ConfigureClear(ClearFlag.Color, Color.clear);
    }
    
    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        if (m_TAAMaterial == null)
            return;
            
        CommandBuffer cmd = CommandBufferPool.Get(k_RenderTag);
        
        // 获取当前帧颜色
        cmd.GetTemporaryRT(k_CurrentColorTextureId, 
            renderingData.cameraData.cameraTargetDescriptor);
        cmd.Blit(renderingData.cameraData.renderer.cameraColorTarget, 
            k_CurrentColorTextureId);
        
        // 执行TAA
        ExecuteTAA(cmd, renderingData);
        
        // 将结果输出到相机目标
        cmd.Blit(m_OutputTexture, 
            renderingData.cameraData.renderer.cameraColorTarget);
        
        cmd.ReleaseTemporaryRT(k_CurrentColorTextureId);
        
        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }
    
    private void ExecuteTAA(CommandBuffer cmd, RenderingData renderingData)
    {
        // 设置TAA参数
        var currentViewProj = renderingData.cameraData.GetViewProjectionMatrix();
        m_TAAMaterial.SetMatrix("_CurrentViewProjectionMatrix", currentViewProj);
        m_TAAMaterial.SetMatrix("_PreviousViewProjectionMatrix", m_PreviousViewProjectionMatrix);
        m_TAAMaterial.SetVector("_ScreenParams", 
            new Vector4(Screen.width, Screen.height, 1.0f / Screen.width, 1.0f / Screen.height));
        
        // 设置纹理
        m_TAAMaterial.SetTexture("_CurrentColorTexture", m_CurrentTexture);
        m_TAAMaterial.SetTexture("_HistoryColorTexture", m_HistoryTexture);
        m_TAAMaterial.SetTexture("_MotionVectorTexture", 
            renderingData.cameraData.renderer.cameraDepthTarget); // 简化处理
        
        // 执行TAA
        cmd.Blit(m_CurrentTexture, m_OutputTexture, m_TAAMaterial, 0);
        
        // 交换历史纹理
        if (m_FirstFrame)
        {
            cmd.Blit(m_CurrentTexture, m_HistoryTexture);
            m_FirstFrame = false;
        }
        else
        {
            cmd.Blit(m_OutputTexture, m_HistoryTexture);
        }
        
        // 更新上一帧的变换矩阵
        m_PreviousViewProjectionMatrix = currentViewProj;
    }
    
    public override void FrameCleanup(CommandBuffer cmd)
    {
        if (m_HistoryTexture != null)
            m_HistoryTexture?.Release();
        if (m_CurrentTexture != null)
            m_CurrentTexture?.Release();
        if (m_OutputTexture != null)
            m_OutputTexture?.Release();
    }
}

public class TemporalAAFeature : ScriptableRendererFeature
{
    [System.Serializable]
    public class TAASettings
    {
        public Material TAAMaterial;
        public RenderPassEvent Event = RenderPassEvent.BeforeRenderingPostProcessing;
        [Range(0.0f, 1.0f)] public float Sharpness = 0.1f;
        [Range(0.0f, 1.0f)] public float StationaryBlending = 0.95f;
        [Range(0.0f, 1.0f)] public float MovingBlending = 0.85f;
        public bool UseJitter = true;
    }
    
    public TAASettings settings = new TAASettings();
    private TemporalAAPass m_TAAPass;
    
    public override void Create()
    {
        if (settings.TAAMaterial == null)
        {
            Debug.LogError("TAA Material is not assigned!");
            return;
        }
        
        m_TAAPass = new TemporalAAPass(settings.Event, settings.TAAMaterial);
    }
    
    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        if (settings.TAAMaterial != null)
        {
            renderer.EnqueuePass(m_TAAPass);
        }
    }
}

// TAA着色器代码（简化版）
/*
Shader "URP/TemporalAA"
{
    Properties
    {
        _MainTex ("Screen Texture", 2D) = "white" {}
        _HistoryTex ("History Texture", 2D) = "white" {}
        _MotionVectorTex ("Motion Vector Texture", 2D) = "black" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" }
        
        Pass
        {
            Name "TAA"
            ZTest Always
            ZWrite Off
            Cull Off
            
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            
            struct Attributes
            {
                float4 positionOS : POSITION;
                float2 uv : TEXCOORD0;
            };
            
            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float2 uv : TEXCOORD0;
            };
            
            TEXTURE2D(_MainTex);    SAMPLER(sampler_MainTex);
            TEXTURE2D(_HistoryTex);    SAMPLER(sampler_HistoryTex);
            TEXTURE2D(_MotionVectorTex);    SAMPLER(sampler_MotionVectorTex);
            
            uniform float4x4 _CurrentViewProjectionMatrix;
            uniform float4x4 _PreviousViewProjectionMatrix;
            uniform float4 _ScreenParams;
            uniform float _Sharpness;
            uniform float _StationaryBlending;
            uniform float _MovingBlending;
            
            Varyings vert(Attributes input)
            {
                Varyings output;
                output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
                output.uv = input.uv;
                return output;
            }
            
            float4 frag(Varyings input) : SV_Target
            {
                float2 uv = input.uv;
                
                // 获取当前帧颜色
                float4 currentColor = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
                
                // 获取运动矢量
                float2 motionVector = SAMPLE_TEXTURE2D(_MotionVectorTex, sampler_MotionVectorTex, uv).xy;
                
                // 重投影到上一帧位置
                float2 prevUV = uv - motionVector;
                
                // 采样历史颜色
                float4 historyColor = SAMPLE_TEXTURE2D(_HistoryTex, sampler_HistoryTex, prevUV);
                
                // 计算混合权重
                float blendFactor = length(motionVector) > 0.001 ? _MovingBlending : _StationaryBlending;
                
                // 时间混合
                float4 finalColor = lerp(historyColor, currentColor, blendFactor);
                
                return finalColor;
            }
            ENDHLSL
        }
    }
}
*/

using System.Collections;
using UnityEngine;
using UnityEngine.Rendering;

public class DynamicResolutionManager : MonoBehaviour
{
    [Header("Resolution Settings")]
    public bool enableDynamicResolution = true;
    [Range(0.5f, 1.0f)] public float minResolutionScale = 0.5f;
    [Range(0.5f, 1.0f)] public float maxResolutionScale = 1.0f;
    [Range(10, 120)] public int targetFrameRate = 60;
    
    [Header("Performance Settings")]
    public float resolutionChangeInterval = 0.5f;
    public float performanceThreshold = 0.1f; // 10%的性能缓冲
    public float resolutionChangeSpeed = 0.1f; // 每秒变化率
    
    [Header("Quality Settings")]
    public int resolutionSteps = 10; // 分辨率调整的步数
    public bool useIntegerScaling = true; // 是否使用整数倍缩放
    
    private float m_CurrentResolutionScale;
    private float m_TargetResolutionScale;
    private float m_LastChangeTime;
    private float m_AverageFrameTime;
    private int m_FrameCount;
    private float m_CumulativeFrameTime;
    private bool m_IsAdjusting;
    
    [System.Serializable]
    public class DynamicResolutionData
    {
        public float currentScale;
        public float targetScale;
        public float targetFrameRate;
        public float currentFrameRate;
        public float averageFrameTime;
        public bool isAdjusting;
        public System.DateTime lastUpdate;
    }
    
    [System.Serializable]
    public class DynamicResolutionSettings
    {
        public float minScale;
        public float maxScale;
        public int targetFPS;
        public float changeInterval;
        public float threshold;
        public bool useIntegerScaling;
        public System.DateTime lastUpdate;
    }
    
    public DynamicResolutionData resolutionData = new DynamicResolutionData();
    public DynamicResolutionSettings settings = new DynamicResolutionSettings();
    
    void Start()
    {
        if (enableDynamicResolution)
        {
            InitializeDynamicResolution();
        }
    }
    
    void Update()
    {
        if (enableDynamicResolution)
        {
            UpdatePerformanceMetrics();
            AdjustResolutionIfNeeded();
        }
    }
    
    private void InitializeDynamicResolution()
    {
        m_CurrentResolutionScale = 1.0f;
        m_TargetResolutionScale = 1.0f;
        m_LastChangeTime = Time.time;
        m_AverageFrameTime = 0f;
        m_FrameCount = 0;
        m_CumulativeFrameTime = 0f;
        m_IsAdjusting = false;
        
        ApplyResolutionScale(m_CurrentResolutionScale);
        
        UpdateSettings();
        Debug.Log("[DynamicResolutionManager] Initialized dynamic resolution system");
    }
    
    private void UpdatePerformanceMetrics()
    {
        m_CumulativeFrameTime += Time.unscaledDeltaTime;
        m_FrameCount++;
        
        if (m_FrameCount >= 30) // 每30帧计算一次平均值
        {
            m_AverageFrameTime = m_CumulativeFrameTime / m_FrameCount;
            m_CumulativeFrameTime = 0f;
            m_FrameCount = 0;
        }
    }
    
    private void AdjustResolutionIfNeeded()
    {
        if (Time.time - m_LastChangeTime >= resolutionChangeInterval)
        {
            float currentFrameRate = 1.0f / m_AverageFrameTime;
            float targetFrameTime = 1.0f / targetFrameRate;
            
            // 计算性能差异
            float performanceDiff = (targetFrameTime - m_AverageFrameTime) / targetFrameTime;
            
            // 根据性能差异调整分辨率
            if (performanceDiff < -performanceThreshold) // 性能不足，降低分辨率
            {
                DecreaseResolution();
            }
            else if (performanceDiff > performanceThreshold && m_TargetResolutionScale < maxResolutionScale) // 性能过剩，提高分辨率
            {
                IncreaseResolution();
            }
            
            m_LastChangeTime = Time.time;
        }
        
        // 平滑调整分辨率
        if (Mathf.Abs(m_CurrentResolutionScale - m_TargetResolutionScale) > 0.001f)
        {
            m_IsAdjusting = true;
            float direction = Mathf.Sign(m_TargetResolutionScale - m_CurrentResolutionScale);
            m_CurrentResolutionScale = Mathf.MoveTowards(m_CurrentResolutionScale, 
                m_TargetResolutionScale, resolutionChangeSpeed * Time.deltaTime);
            
            ApplyResolutionScale(m_CurrentResolutionScale);
        }
        else
        {
            m_IsAdjusting = false;
        }
        
        UpdateResolutionData();
    }
    
    private void DecreaseResolution()
    {
        float newScale = m_TargetResolutionScale;
        
        if (useIntegerScaling)
        {
            // 使用整数步长
            int currentStep = Mathf.RoundToInt(m_TargetResolutionScale * resolutionSteps);
            newScale = Mathf.Max(minResolutionScale, (currentStep - 1) / (float)resolutionSteps);
        }
        else
        {
            // 使用连续步长
            newScale = Mathf.Max(minResolutionScale, m_TargetResolutionScale - 0.1f);
        }
        
        m_TargetResolutionScale = newScale;
    }
    
    private void IncreaseResolution()
    {
        float newScale = m_TargetResolutionScale;
        
        if (useIntegerScaling)
        {
            // 使用整数步长
            int currentStep = Mathf.RoundToInt(m_TargetResolutionScale * resolutionSteps);
            newScale = Mathf.Min(maxResolutionScale, (currentStep + 1) / (float)resolutionSteps);
        }
        else
        {
            // 使用连续步长
            newScale = Mathf.Min(maxResolutionScale, m_TargetResolutionScale + 0.1f);
        }
        
        m_TargetResolutionScale = newScale;
    }
    
    private void ApplyResolutionScale(float scale)
    {
        scale = Mathf.Clamp(scale, minResolutionScale, maxResolutionScale);
        
        int width = Mathf.RoundToInt(Screen.width * scale);
        int height = Mathf.RoundToInt(Screen.height * scale);
        
        // 应用动态分辨率
        UnityEngine.Rendering.RenderPipelineManager.currentPipeline?.SetSupportedRenderingFeatures(
            new SupportedRenderingFeatures()
            {
                resolutionScaling = true
            });
        
        // 在URP中，我们通常通过后处理来实现动态分辨率效果
        // 这里我们设置一个全局着色器参数
        Shader.SetGlobalVector("_DynamicResolutionScale", new Vector2(scale, scale));
        Shader.SetGlobalVector("_DynamicResolutionOffset", 
            new Vector2((Screen.width - width) / 2.0f, (Screen.height - height) / 2.0f));
    }
    
    private void UpdateResolutionData()
    {
        resolutionData.currentScale = m_CurrentResolutionScale;
        resolutionData.targetScale = m_TargetResolutionScale;
        resolutionData.targetFrameRate = targetFrameRate;
        resolutionData.currentFrameRate = 1.0f / m_AverageFrameTime;
        resolutionData.averageFrameTime = m_AverageFrameTime;
        resolutionData.isAdjusting = m_IsAdjusting;
        resolutionData.lastUpdate = System.DateTime.Now;
    }
    
    private void UpdateSettings()
    {
        settings.minScale = minResolutionScale;
        settings.maxScale = maxResolutionScale;
        settings.targetFPS = targetFrameRate;
        settings.changeInterval = resolutionChangeInterval;
        settings.threshold = performanceThreshold;
        settings.useIntegerScaling = useIntegerScaling;
        settings.lastUpdate = System.DateTime.Now;
    }
    
    // 获取当前分辨率数据
    public DynamicResolutionData GetResolutionData()
    {
        return resolutionData;
    }
    
    // 获取当前设置
    public DynamicResolutionSettings GetSettings()
    {
        return settings;
    }
    
    // 设置目标分辨率缩放
    public void SetTargetResolutionScale(float scale)
    {
        m_TargetResolutionScale = Mathf.Clamp(scale, minResolutionScale, maxResolutionScale);
    }
    
    // 获取当前分辨率缩放
    public float GetCurrentResolutionScale()
    {
        return m_CurrentResolutionScale;
    }
    
    // 获取目标分辨率缩放
    public float GetTargetResolutionScale()
    {
        return m_TargetResolutionScale;
    }
    
    // 重置到默认分辨率
    public void ResetToDefault()
    {
        m_TargetResolutionScale = 1.0f;
        m_CurrentResolutionScale = 1.0f;
        ApplyResolutionScale(1.0f);
    }
    
    // 获取性能摘要
    public string GetPerformanceSummary()
    {
        return $"Resolution Scale: {m_CurrentResolutionScale:F2}, " +
               $"Target: {m_TargetResolutionScale:F2}, " +
               $"Current FPS: {resolutionData.currentFrameRate:F1}, " +
               $"Target FPS: {targetFrameRate}, " +
               $"Adjusting: {m_IsAdjusting}";
    }
    
    // 获取分辨率优化建议
    public string GetResolutionSuggestions()
    {
        var suggestions = new System.Text.StringBuilder();
        
        if (resolutionData.currentFrameRate < targetFrameRate * 0.8f)
        {
            suggestions.AppendLine("• 帧率过低，建议保持较低分辨率");
        }
        else if (resolutionData.currentFrameRate > targetFrameRate * 1.2f)
        {
            suggestions.AppendLine("• 性能良好，可以适当提高分辨率");
        }
        
        if (m_CurrentResolutionScale < minResolutionScale + 0.1f)
        {
            suggestions.AppendLine("• 分辨率已达到最低值，考虑其他优化方法");
        }
        
        if (m_CurrentResolutionScale > maxResolutionScale - 0.1f)
        {
            suggestions.AppendLine("• 分辨率已达到最高值，性能可能成为瓶颈");
        }
        
        return suggestions.ToString();
    }
    
    // 获取分辨率报告
    public string GetResolutionReport()
    {
        var report = new System.Text.StringBuilder();
        report.AppendLine("=== Dynamic Resolution Report ===");
        report.AppendLine($"Current Scale: {resolutionData.currentScale:F3}");
        report.AppendLine($"Target Scale: {resolutionData.targetScale:F3}");
        report.AppendLine($"Target FPS: {resolutionData.targetFrameRate}");
        report.AppendLine($"Current FPS: {resolutionData.currentFrameRate:F1}");
        report.AppendLine($"Average Frame Time: {resolutionData.averageFrameTime * 1000:F1}ms");
        report.AppendLine($"Is Adjusting: {resolutionData.isAdjusting}");
        report.AppendLine($"Last Update: {resolutionData.lastUpdate}");
        
        return report.ToString();
    }
    
    void OnDestroy()
    {
        // 清理全局着色器参数
        Shader.SetGlobalVector("_DynamicResolutionScale", Vector2.one);
        Shader.SetGlobalVector("_DynamicResolutionOffset", Vector2.zero);
    }
}

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

[RequireComponent(typeof(MeshRenderer), typeof(MeshFilter))]
public class WaterRenderer : MonoBehaviour
{
    [Header("Water Properties")]
    public float waterHeight = 0f;
    public Color waterColor = new Color(0.1f, 0.3f, 0.6f, 0.7f);
    public float waterDensity = 0.5f;
    public float waveSpeed = 1.0f;
    public float waveHeight = 0.1f;
    public float waveFrequency = 1.0f;
    
    [Header("Reflection Settings")]
    public bool enableReflection = true;
    public int reflectionResolution = 512;
    public float reflectionDistance = 100f;
    
    [Header("Refraction Settings")]
    public bool enableRefraction = true;
    [Range(0.0f, 1.0f)] public float refractionStrength = 0.1f;
    
    [Header("Foam Settings")]
    public bool enableFoam = true;
    public float foamSpread = 0.5f;
    public float foamIntensity = 1.0f;
    
    [Header("Caustics Settings")]
    public bool enableCaustics = false;
    public float causticsIntensity = 0.5f;
    public float causticsScale = 10f;
    
    [Header("Performance Settings")]
    public bool enableLOD = true;
    public float lodDistance = 50f;
    
    private Camera m_ReflectionCamera;
    private RenderTexture m_ReflectionTexture;
    private Material m_WaterMaterial;
    private MeshRenderer m_MeshRenderer;
    private List<WaterInteraction> m_Interactions = new List<WaterInteraction>();
    
    [System.Serializable]
    public class WaterProperties
    {
        public float height;
        public Color color;
        public float density;
        public float waveSpeed;
        public float waveHeight;
        public float waveFrequency;
        public float refractionStrength;
        public float foamSpread;
        public float foamIntensity;
        public float causticsIntensity;
        public System.DateTime lastUpdate;
    }
    
    [System.Serializable]
    public class WaterInteraction
    {
        public Transform objectTransform;
        public Vector3 lastPosition;
        public float interactionRadius;
        public float intensity;
        public System.DateTime lastInteraction;
    }
    
    public WaterProperties waterProperties = new WaterProperties();
    
    void Start()
    {
        InitializeWaterRenderer();
    }
    
    void Update()
    {
        UpdateWaterProperties();
        UpdateReflectionCamera();
        UpdateInteractions();
    }
    
    private void InitializeWaterRenderer()
    {
        m_MeshRenderer = GetComponent<MeshRenderer>();
        if (m_MeshRenderer != null && m_MeshRenderer.sharedMaterials.Length > 0)
        {
            m_WaterMaterial = m_MeshRenderer.sharedMaterials[0];
            UpdateMaterialProperties();
        }
        
        if (enableReflection)
        {
            CreateReflectionCamera();
        }
        
        UpdateWaterProperties();
        
        Debug.Log("[WaterRenderer] Initialized water rendering system");
    }
    
    private void CreateReflectionCamera()
    {
        GameObject reflectionCameraObj = new GameObject("WaterReflectionCamera");
        m_ReflectionCamera = reflectionCameraObj.AddComponent<Camera>();
        m_ReflectionCamera.enabled = false;
        m_ReflectionCamera.renderingPath = RenderingPath.Forward;
        m_ReflectionCamera.backgroundColor = Color.black;
        m_ReflectionCamera.clearFlags = CameraClearFlags.SolidColor;
        
        m_ReflectionTexture = new RenderTexture(reflectionResolution, reflectionResolution, 16);
        m_ReflectionTexture.name = "WaterReflectionTexture";
        m_ReflectionCamera.targetTexture = m_ReflectionTexture;
    }
    
    private void UpdateWaterProperties()
    {
        waterProperties.height = waterHeight;
        waterProperties.color = waterColor;
        waterProperties.density = waterDensity;
        waterProperties.waveSpeed = waveSpeed;
        waterProperties.waveHeight = waveHeight;
        waterProperties.waveFrequency = waveFrequency;
        waterProperties.refractionStrength = refractionStrength;
        waterProperties.foamSpread = foamSpread;
        waterProperties.foamIntensity = foamIntensity;
        waterProperties.causticsIntensity = causticsIntensity;
        waterProperties.lastUpdate = System.DateTime.Now;
    }
    
    private void UpdateMaterialProperties()
    {
        if (m_WaterMaterial != null)
        {
            m_WaterMaterial.SetColor("_WaterColor", waterColor);
            m_WaterMaterial.SetFloat("_WaterDensity", waterDensity);
            m_WaterMaterial.SetFloat("_WaveSpeed", waveSpeed);
            m_WaterMaterial.SetFloat("_WaveHeight", waveHeight);
            m_WaterMaterial.SetFloat("_WaveFrequency", waveFrequency);
            m_WaterMaterial.SetFloat("_RefractionStrength", refractionStrength);
            m_WaterMaterial.SetFloat("_FoamSpread", foamSpread);
            m_WaterMaterial.SetFloat("_FoamIntensity", foamIntensity);
            m_WaterMaterial.SetFloat("_CausticsIntensity", causticsIntensity);
            m_WaterMaterial.SetFloat("_CausticsScale", causticsScale);
            
            if (enableReflection && m_ReflectionTexture != null)
            {
                m_WaterMaterial.SetTexture("_ReflectionTexture", m_ReflectionTexture);
            }
        }
    }
    
    private void UpdateReflectionCamera()
    {
        if (!enableReflection || m_ReflectionCamera == null) return;
        
        // 计算反射相机位置和旋转
        Vector3 pos = transform.position;
        Vector3 normal = transform.up;
        float d = -Vector3.Dot(normal, pos) - waterHeight;
        Vector3 reflectionPos = pos - 2 * d * normal;
        
        m_ReflectionCamera.worldToCameraMatrix = 
            Camera.main.worldToCameraMatrix * Matrix4x4.Scale(new Vector3(1, -1, 1));
        
        Vector3 euler = Camera.main.transform.eulerAngles;
        m_ReflectionCamera.transform.eulerAngles = new Vector3(-euler.x, euler.y, euler.z);
        m_ReflectionCamera.transform.position = new Vector3(
            Camera.main.transform.position.x,
            -Camera.main.transform.position.y + waterHeight * 2,
            Camera.main.transform.position.z);
        
        // 设置剪裁平面
        Vector4 clipPlane = new Vector4(normal.x, normal.y, normal.z, d);
        m_ReflectionCamera.projectionMatrix = 
            Camera.main.CalculateObliqueMatrix(clipPlane);
        
        // 渲染反射
        m_ReflectionCamera.Render();
    }
    
    private void UpdateInteractions()
    {
        // 更新与水的交互效果
        for (int i = m_Interactions.Count - 1; i >= 0; i--)
        {
            var interaction = m_Interactions[i];
            if (interaction.objectTransform == null)
            {
                m_Interactions.RemoveAt(i);
                continue;
            }
            
            // 检查对象是否还在水面上
            float distanceToWater = Mathf.Abs(interaction.objectTransform.position.y - waterHeight);
            if (distanceToWater > interaction.interactionRadius)
            {
                m_Interactions.RemoveAt(i);
            }
            else
            {
                // 更新交互效果
                UpdateInteractionEffect(interaction);
            }
        }
    }
    
    private void UpdateInteractionEffect(WaterInteraction interaction)
    {
        // 计算对象移动对水面的影响
        Vector3 currentPos = interaction.objectTransform.position;
        Vector3 displacement = currentPos - interaction.lastPosition;
        
        if (m_WaterMaterial != null)
        {
            // 传递交互参数到着色器
            m_WaterMaterial.SetVector("_InteractionPos", 
                new Vector4(currentPos.x, currentPos.z, interaction.intensity, 0));
            m_WaterMaterial.SetVector("_InteractionVel", 
                new Vector4(displacement.x, displacement.z, displacement.magnitude, 0));
        }
        
        interaction.lastPosition = currentPos;
        interaction.lastInteraction = System.DateTime.Now;
    }
    
    // 添加水交互
    public void AddWaterInteraction(Transform obj, float radius = 1.0f, float intensity = 1.0f)
    {
        var interaction = new WaterInteraction
        {
            objectTransform = obj,
            lastPosition = obj.position,
            interactionRadius = radius,
            intensity = intensity,
            lastInteraction = System.DateTime.Now
        };
        
        m_Interactions.Add(interaction);
    }
    
    // 移除水交互
    public void RemoveWaterInteraction(Transform obj)
    {
        m_Interactions.RemoveAll(interaction => interaction.objectTransform == obj);
    }
    
    // 获取水属性
    public WaterProperties GetWaterProperties()
    {
        return waterProperties;
    }
    
    // 设置水颜色
    public void SetWaterColor(Color color)
    {
        waterColor = color;
        if (m_WaterMaterial != null)
        {
            m_WaterMaterial.SetColor("_WaterColor", color);
        }
    }
    
    // 设置波浪参数
    public void SetWaveParameters(float speed, float height, float frequency)
    {
        waveSpeed = speed;
        waveHeight = height;
        waveFrequency = frequency;
        
        if (m_WaterMaterial != null)
        {
            m_WaterMaterial.SetFloat("_WaveSpeed", speed);
            m_WaterMaterial.SetFloat("_WaveHeight", height);
            m_WaterMaterial.SetFloat("_WaveFrequency", frequency);
        }
    }
    
    // 设置折射强度
    public void SetRefractionStrength(float strength)
    {
        refractionStrength = Mathf.Clamp01(strength);
        if (m_WaterMaterial != null)
        {
            m_WaterMaterial.SetFloat("_RefractionStrength", strength);
        }
    }
    
    // 设置泡沫参数
    public void SetFoamParameters(float spread, float intensity)
    {
        foamSpread = spread;
        foamIntensity = intensity;
        
        if (m_WaterMaterial != null)
        {
            m_WaterMaterial.SetFloat("_FoamSpread", spread);
            m_WaterMaterial.SetFloat("_FoamIntensity", intensity);
        }
    }
    
    // 获取交互列表
    public List<WaterInteraction> GetInteractions()
    {
        return new List<WaterInteraction>(m_Interactions);
    }
    
    // 获取水体渲染摘要
    public string GetWaterRenderingSummary()
    {
        return $"Water Height: {waterHeight:F2}, " +
               $"Reflection: {(enableReflection ? "On" : "Off")}, " +
               $"Refraction: {(enableRefraction ? "On" : "Off")}, " +
               $"Interactions: {m_Interactions.Count}, " +
               $"LOD: {(enableLOD ? "On" : "Off")}";
    }
    
    // 获取水体优化建议
    public string GetWaterOptimizationSuggestions()
    {
        var suggestions = new System.Text.StringBuilder();
        
        if (reflectionResolution > 1024)
        {
            suggestions.AppendLine("• 反射分辨率过高，考虑降低以提升性能");
        }
        
        if (enableCaustics)
        {
            suggestions.AppendLine("• 焦散效果性能开销较大，可考虑在低端设备上禁用");
        }
        
        if (m_Interactions.Count > 10)
        {
            suggestions.AppendLine("• 水交互对象过多，考虑限制同时交互的数量");
        }
        
        return suggestions.ToString();
    }
    
    // 获取水体报告
    public string GetWaterReport()
    {
        var report = new System.Text.StringBuilder();
        report.AppendLine("=== Water Rendering Report ===");
        report.AppendLine($"Water Height: {waterProperties.height:F2}");
        report.AppendLine($"Water Color: {waterProperties.color}");
        report.AppendLine($"Wave Speed: {waterProperties.waveSpeed:F2}");
        report.AppendLine($"Wave Height: {waterProperties.waveHeight:F2}");
        report.AppendLine($"Density: {waterProperties.density:F2}");
        report.AppendLine($"Reflection: {(enableReflection ? "Enabled" : "Disabled")}");
        report.AppendLine($"Refraction: {(enableRefraction ? "Enabled" : "Disabled")}");
        report.AppendLine($"Foam: {(enableFoam ? "Enabled" : "Disabled")}");
        report.AppendLine($"Caustics: {(enableCaustics ? "Enabled" : "Disabled")}");
        report.AppendLine($"Interactions: {m_Interactions.Count}");
        report.AppendLine($"Last Update: {waterProperties.lastUpdate}");
        
        return report.ToString();
    }
    
    void OnDestroy()
    {
        if (m_ReflectionTexture != null)
        {
            m_ReflectionTexture.Release();
            m_ReflectionTexture = null;
        }
        
        if (m_ReflectionCamera != null)
        {
            DestroyImmediate(m_ReflectionCamera.gameObject);
        }
    }
}