View difference between Paste ID: VWcPUba1 and pq1BfY49

 using UnityEditor;
 using UnityEngine;
 using UnityEngine.Profiling;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEngine.Rendering;
 
 public class GpuTimingWindow : EditorWindow
 {
     private const int SampleCount = 1;
     private FrameTiming[] frameTimings = new FrameTiming[SampleCount];
     private double gpuFrameTime;
     private double cpuFrameTime;
 
     private const int HistorySize = 50;
     private Queue<float> cpuHistory = new Queue<float>(HistorySize);
     private Queue<float> gpuHistory = new Queue<float>(HistorySize);
 
     private Shader shaderToProfile;
     private CustomSampler shaderSampler;
 
     [MenuItem("Window/Analysis/GPU Timing Viewer")]
     public static void ShowWindow()
     {
         var window = GetWindow<GpuTimingWindow>("GPU Timing");
         window.Show();
     }
 
     private void OnEnable()
     {
         EditorApplication.update += UpdateTimings;
     }
 
     private void OnDisable()
     {
         EditorApplication.update -= UpdateTimings;
     }
 
     private void UpdateTimings()
     {
         // Capture frame timings from the last frame
         FrameTimingManager.CaptureFrameTimings();
         uint count = FrameTimingManager.GetLatestTimings((uint)frameTimings.Length, frameTimings);
 
         if (count > 0)
         {
             var timing = frameTimings[0];
             gpuFrameTime = timing.gpuFrameTime;
             cpuFrameTime = timing.cpuFrameTime;
 
             AddToHistory(cpuHistory, (float)cpuFrameTime);
             AddToHistory(gpuHistory, (float)gpuFrameTime);
 
             Repaint();
         }
     }
 
     private void AddToHistory(Queue<float> queue, float value)
     {
         if (queue.Count >= HistorySize)
             queue.Dequeue();
         queue.Enqueue(value);
     }
 
     private float GetAverage(Queue<float> queue)
     {
         if (queue.Count == 0) return 0f;
         return queue.Average();
     }
 
     private void OnGUI()
     {
         GUILayout.Label("GPU & CPU Frame Timing", EditorStyles.boldLabel);
 
         EditorGUILayout.LabelField("CPU Frame Time (ms):", cpuFrameTime.ToString("F2"));
         EditorGUILayout.LabelField("GPU Frame Time (ms):", gpuFrameTime.ToString("F2"));
 
         float avgCpu = GetAverage(cpuHistory);
         float avgGpu = GetAverage(gpuHistory);
 
         EditorGUILayout.Space();
         EditorGUILayout.LabelField("CPU Avg (200 frames, ms):", avgCpu.ToString("F2"));
         EditorGUILayout.LabelField("GPU Avg (200 frames, ms):", avgGpu.ToString("F2"));
 
         float targetFrameRate = 1000f / Mathf.Max(0.0001f, avgGpu);
         EditorGUILayout.LabelField("Approx. Avg GPU FPS:", targetFrameRate.ToString("F1"));
 
         GUILayout.Space(10);
         Rect rect = GUILayoutUtility.GetRect(100, 30);
         DrawTimingBar(rect, (float)cpuFrameTime, (float)gpuFrameTime);
 
         GUILayout.Space(20);
         GUILayout.Label("Frame Timing History (last 200 frames)", EditorStyles.boldLabel);
         Rect graphRect = GUILayoutUtility.GetRect(position.width - 20, 100);
         DrawGraph(graphRect, cpuHistory, gpuHistory);
     }
 
     private void DrawTimingBar(Rect rect, float cpuMs, float gpuMs)
     {
         float maxMs = Mathf.Max(cpuMs, gpuMs, 16.67f); // baseline at ~60 FPS
         float cpuWidth = Mathf.Clamp01(cpuMs / maxMs) * rect.width;
         float gpuWidth = Mathf.Clamp01(gpuMs / maxMs) * rect.width;
 
         EditorGUI.DrawRect(new Rect(rect.x, rect.y, cpuWidth, rect.height / 2), new Color(0.3f, 0.6f, 1f));
         EditorGUI.DrawRect(new Rect(rect.x, rect.y + rect.height / 2, gpuWidth, rect.height / 2), new Color(1f, 0.4f, 0.4f));
 
         EditorGUI.DropShadowLabel(rect, $"CPU {cpuMs:F2} ms | GPU {gpuMs:F2} ms");
     }
 
     private void DrawGraph(Rect rect, Queue<float> cpuData, Queue<float> gpuData)
     {
         Handles.BeginGUI();
         GUI.Box(rect, GUIContent.none);
 
         if (cpuData.Count > 1 && gpuData.Count > 1)
         {
             float[] cpuArray = cpuData.ToArray();
             float[] gpuArray = gpuData.ToArray();
             int count = Mathf.Min(cpuArray.Length, gpuArray.Length);
 
             float maxVal = 0f;
             for (int i = 0; i < count; i++)
                 maxVal = Mathf.Max(maxVal, Mathf.Max(cpuArray[i], gpuArray[i]));
 
             if (maxVal < 16.67f)
                 maxVal = 16.67f; // ensure ~60 fps baseline is visible
 
             Vector3 prevCpu = Vector3.zero;
             Vector3 prevGpu = Vector3.zero;
             for (int i = 0; i < count; i++)
             {
                 float x = Mathf.Lerp(rect.x, rect.xMax, i / (float)(count - 1));
                 float cpuY = Mathf.Lerp(rect.yMax, rect.y, cpuArray[i] / maxVal);
                 float gpuY = Mathf.Lerp(rect.yMax, rect.y, gpuArray[i] / maxVal);
 
                 Vector3 cpuPoint = new Vector3(x, cpuY, 0);
                 Vector3 gpuPoint = new Vector3(x, gpuY, 0);
 
                 if (i > 0)
                 {
                     Handles.color = new Color(0.3f, 0.6f, 1f);
                     Handles.DrawLine(prevCpu, cpuPoint);
 
                     Handles.color = new Color(1f, 0.4f, 0.4f);
                     Handles.DrawLine(prevGpu, gpuPoint);
                 }
 
                 prevCpu = cpuPoint;
                 prevGpu = gpuPoint;
             }
         }
 
         Handles.EndGUI();
     }
 }