@funpixel/tools 0.0.0-stage → 0.1.1

package/unity/com.funpixel.probe/Runtime/Player/Probe.cs

@@ -0,0 +1,194 @@
+// The probe: every frame in the player, read from the engine's own counters (ProfilerRecorder), which work in
+// development players where UnityStats reads 0 in batch mode. Learned from the studio's five probes, each written for
+// one game: hitch probes, perf probes and a perf recorder
+// (the Unity 6 draw counters, the player loop minus its waits as the frame's work).
+//
+// A frame is reported by the frame after it: Unity's counters and a frame's length are known once it has ended, so
+// Update (first in the frame) records the one before. Frames are left out of the numbers, and counted, when they are
+// the warm-up, a capture (ours, or the game's FunpixelProbe.MarkCapture) and the 4 after it, or a scene load.
+using System.Collections.Generic;
+using Unity.Profiling;
+using UnityEngine;
+
+namespace Funpixel.Probe
+{
+    [DefaultExecutionOrder(-32000)]
+    public sealed class Probe : MonoBehaviour
+    {
+        public static Probe Instance { get; private set; }
+
+        public const int DefaultCapacity = 36000;
+        public bool Running { get; private set; }
+        public readonly Exclusions Skips = new Exclusions(60);
+
+        ProfilerRecorder main, render, playerLoop, waitFps, waitPresent, gcAlloc, drawsStd, drawsNull, drawsAll, setPass, batches, tris, memTotal, memSystem, memGc;
+        readonly FrameTiming[] timing = new FrameTiming[1];
+        FrameSample[] samples = new FrameSample[DefaultCapacity];
+        int count;
+        bool truncated;
+        int segment;
+        readonly List<string> segments = new List<string> { "run" };
+        double last = -1;
+        int lastGameCapture = -1;
+        double hitchMs = -1;
+
+        public static Probe Ensure(GameObject host)
+        {
+            if (Instance != null) return Instance;
+            Instance = host.AddComponent<Probe>();
+            return Instance;
+        }
+
+        /// <summary>A frame longer than this (ms) is a hitch: -fp-hitch-ms, else two frames at the target rate.</summary>
+        public double HitchMs
+        {
+            get
+            {
+                if (hitchMs > 0) return hitchMs;
+                int fps = Application.targetFrameRate > 0 ? Application.targetFrameRate : 60;
+                return 2000.0 / fps;
+            }
+            set { hitchMs = value; }
+        }
+
+        void OnEnable()
+        {
+            main = ProfilerRecorder.StartNew(ProfilerCategory.Internal, "Main Thread", 1);
+            render = ProfilerRecorder.StartNew(ProfilerCategory.Internal, "Render Thread", 1);
+            playerLoop = ProfilerRecorder.StartNew(ProfilerCategory.Internal, "PlayerLoop", 1);
+            waitFps = ProfilerRecorder.StartNew(ProfilerCategory.Internal, "WaitForTargetFPS", 1);
+            waitPresent = ProfilerRecorder.StartNew(ProfilerCategory.Render, "Gfx.WaitForPresentOnGfxThread", 1);
+            gcAlloc = ProfilerRecorder.StartNew(ProfilerCategory.Memory, "GC Allocated In Frame", 1);
+            // Unity 6 split the draw counter: standard draws plus the null-geometry (full-screen) ones; older players have one.
+            drawsStd = ProfilerRecorder.StartNew(ProfilerCategory.Render, "Standard Draw Calls Count", 1);
+            drawsNull = ProfilerRecorder.StartNew(ProfilerCategory.Render, "Null Geometry Draw Calls Count", 1);
+            drawsAll = ProfilerRecorder.StartNew(ProfilerCategory.Render, "Draw Calls Count", 1);
+            setPass = ProfilerRecorder.StartNew(ProfilerCategory.Render, "SetPass Calls Count", 1);
+            batches = ProfilerRecorder.StartNew(ProfilerCategory.Render, "Batches Count", 1);
+            tris = ProfilerRecorder.StartNew(ProfilerCategory.Render, "Triangles Count", 1);
+            memTotal = ProfilerRecorder.StartNew(ProfilerCategory.Memory, "Total Used Memory", 1);
+            memSystem = ProfilerRecorder.StartNew(ProfilerCategory.Memory, "System Used Memory", 1);
+            memGc = ProfilerRecorder.StartNew(ProfilerCategory.Memory, "GC Used Memory", 1);
+        }
+
+        void OnDisable()
+        {
+            main.Dispose(); render.Dispose(); playerLoop.Dispose(); waitFps.Dispose(); waitPresent.Dispose(); gcAlloc.Dispose();
+            drawsStd.Dispose(); drawsNull.Dispose(); drawsAll.Dispose(); setPass.Dispose(); batches.Dispose(); tris.Dispose();
+            memTotal.Dispose(); memSystem.Dispose(); memGc.Dispose();
+        }
+
+        void OnDestroy() { if (Instance == this) Instance = null; }
+
+        /// <summary>Start (or restart) measuring: the numbers so far are dropped.</summary>
+        public void Begin(int warmupFrames, int capacity = DefaultCapacity)
+        {
+            if (capacity != samples.Length) samples = new FrameSample[Mathf.Max(600, capacity)];
+            count = 0; truncated = false; segment = 0;
+            segments.Clear(); segments.Add("run");
+            Skips.WarmupFrames = Mathf.Max(0, warmupFrames);
+            Skips.Start(Time.frameCount);
+            last = -1;
+            Running = true;
+        }
+
+        public void Stop() { Running = false; }
+
+        /// <summary>Frames from the next one on count under a new label (a script's "segment").</summary>
+        public int Segment(string label)
+        {
+            segments.Add(string.IsNullOrEmpty(label) ? "segment " + segments.Count : label);
+            segment = segments.Count - 1;
+            return segment;
+        }
+
+        public void MarkCapture() => Skips.Capture(Time.frameCount);
+        public void LoadBegin() => Skips.LoadBegin(Time.frameCount);
+        public void LoadEnd() => Skips.LoadEnd(Time.frameCount);
+
+        static double Ms(ProfilerRecorder r) => r.Valid && r.Count > 0 ? r.LastValue * 1e-6 : -1;
+        static long Num(ProfilerRecorder r) => r.Valid && r.Count > 0 ? r.LastValue : -1;
+
+        void Update()
+        {
+            double now = Time.realtimeSinceStartupAsDouble;
+            FrameTimingManager.CaptureFrameTimings();
+            if (FunpixelProbe.CaptureFrame != lastGameCapture) { lastGameCapture = FunpixelProbe.CaptureFrame; if (lastGameCapture >= 0) Skips.Capture(lastGameCapture); }
+            if (!Running) { last = now; return; }
+            int frame = Time.frameCount - 1;
+            if (last < 0) { last = now; return; }
+            var s = FrameSample.Empty(frame);
+            s.Ms = (now - last) * 1000.0;
+            last = now;
+            s.Segment = segment;
+            s.Main = Ms(main);
+            s.Render = Ms(render);
+            double loop = Ms(playerLoop);
+            if (loop >= 0) s.Work = System.Math.Max(0, loop - System.Math.Max(0, Ms(waitFps)) - System.Math.Max(0, Ms(waitPresent)));
+            s.GameWork = FunpixelProbe.TakeWork(frame);
+            if (FrameTimingManager.GetLatestTimings(1, timing) > 0 && timing[0].gpuFrameTime > 0) s.Gpu = timing[0].gpuFrameTime;
+            s.Gc = Num(gcAlloc);
+            long std = Num(drawsStd), nul = Num(drawsNull);
+            s.Draws = std >= 0 ? std + System.Math.Max(0, nul) : Num(drawsAll);
+            s.SetPass = Num(setPass);
+            s.Batches = Num(batches);
+            s.Tris = Num(tris);
+            s.MemTotal = Num(memTotal);
+            s.MemSystem = Num(memSystem);
+            s.MemGc = Num(memGc);
+            s.Note = FunpixelProbe.TakeNote(frame);
+            s.Skip = Skips.Of(frame);
+            if (count < samples.Length) samples[count++] = s;
+            else truncated = true;
+        }
+
+        /// <summary>Which counter each column came from in this player, or null when it has none (not observed).</summary>
+        Dictionary<string, object> Counters()
+        {
+            string Name(ProfilerRecorder r, string n) => r.Valid ? n : null;
+            return new Dictionary<string, object>
+            {
+                { "main", Name(main, "Main Thread") }, { "render", Name(render, "Render Thread") },
+                { "work", playerLoop.Valid ? "PlayerLoop - WaitForTargetFPS - Gfx.WaitForPresentOnGfxThread" : null },
+                { "game_work", "FunpixelProbe.WorkBegin/WorkEnd" },
+                { "gpu", FrameTimingManager.IsFeatureEnabled() ? "FrameTimingManager.gpuFrameTime" : null },
+                { "gc", Name(gcAlloc, "GC Allocated In Frame") },
+                { "draws", drawsStd.Valid ? "Standard Draw Calls Count + Null Geometry Draw Calls Count" : Name(drawsAll, "Draw Calls Count") },
+                { "setpass", Name(setPass, "SetPass Calls Count") }, { "batches", Name(batches, "Batches Count") }, { "tris", Name(tris, "Triangles Count") },
+                { "memory", Name(memTotal, "Total Used Memory") },
+            };
+        }
+
+        public static Dictionary<string, object> Meta()
+        {
+            var safe = Screen.safeArea;
+            return new Dictionary<string, object>
+            {
+                { "unity", Application.unityVersion }, { "platform", Application.platform.ToString() },
+                { "product", Application.productName }, { "version", Application.version }, { "bundle", Application.identifier },
+                { "device", SystemInfo.deviceModel }, { "gpu", SystemInfo.graphicsDeviceName }, { "graphics_api", SystemInfo.graphicsDeviceType.ToString() },
+                { "cpu_count", SystemInfo.processorCount }, { "memory_mb", SystemInfo.systemMemorySize },
+                { "screen", new Dictionary<string, object> {
+                    { "w", Screen.width }, { "h", Screen.height }, { "dpi", Screen.dpi }, { "orientation", Screen.orientation.ToString() },
+                    { "refresh_hz", Screen.currentResolution.refreshRateRatio.value },
+                    { "safe", new object[] { safe.xMin, safe.yMin, safe.width, safe.height } } } },
+                { "target_fps", Application.targetFrameRate }, { "vsync", QualitySettings.vSyncCount },
+                { "quality", QualitySettings.names.Length > 0 ? QualitySettings.names[QualitySettings.GetQualityLevel()] : null },
+                { "development", Debug.isDebugBuild }, { "batchmode", Application.isBatchMode }, { "editor", Application.isEditor },
+                { "time", System.DateTime.UtcNow.ToString("o") },
+            };
+        }
+
+        public Dictionary<string, object> Report(bool rows = true)
+        {
+            var input = new ReportInput
+            {
+                Samples = samples, Count = count, Truncated = truncated, HitchMs = HitchMs, Segments = new List<string>(segments),
+                Rows = rows, Meta = Meta(), Counters = Counters(),
+            };
+            var o = ProbeReport.Build(input);
+            o["running"] = Running;
+            return o;
+        }
+    }
+}

package/unity/com.funpixel.probe/Runtime/Player/Probe.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 50117add07f5ee8cf5ae6bd75545a785
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/unity/com.funpixel.probe/Runtime/Player/Stats.cs

@@ -0,0 +1,266 @@
+// The probe's arithmetic, engine-free (dotnet test runs it in Tests~): which frames are left out and why, the
+// percentiles, the hitches with what was in them, and the report's JSON shape (schema funpixel.probe/1, which
+// funtools' src/unity/probe/report.ts reads). Nothing here touches UnityEngine.
+using System;
+using System.Collections.Generic;
+
+namespace Funpixel.Probe
+{
+    /// <summary>Why a frame is left out of the numbers.</summary>
+    public enum Skip : byte { None = 0, Warmup = 1, Capture = 2, Load = 3 }
+
+    /// <summary>One frame as the probe measured it. Times in ms, memory in bytes; -1 is "not observed".</summary>
+    public struct FrameSample
+    {
+        public int Frame;
+        public int Segment;
+        public Skip Skip;
+        /// <summary>The frame's wall time (real time between two frames).</summary>
+        public double Ms;
+        /// <summary>Main and render thread time (ProfilerRecorder "Main Thread", "Render Thread").</summary>
+        public double Main, Render;
+        /// <summary>The player loop minus its waits (WaitForTargetFPS, waiting for present): the engine's and the game's work.</summary>
+        public double Work;
+        /// <summary>The game's own work, from FunpixelProbe.WorkBegin/WorkEnd.</summary>
+        public double GameWork;
+        /// <summary>GPU time (FrameTimingManager; needs Player Settings "Frame Timing Stats").</summary>
+        public double Gpu;
+        public long Gc, Draws, SetPass, Batches, Tris;
+        public long MemTotal, MemSystem, MemGc;
+        public string Note;
+
+        public static FrameSample Empty(int frame) => new FrameSample
+        {
+            Frame = frame, Ms = -1, Main = -1, Render = -1, Work = -1, GameWork = -1, Gpu = -1,
+            Gc = -1, Draws = -1, SetPass = -1, Batches = -1, Tris = -1, MemTotal = -1, MemSystem = -1, MemGc = -1,
+        };
+    }
+
+    /// <summary>Which frames are left out: the warm-up, every capture frame and the <see cref="CaptureTail"/> after it
+    /// (a ScreenCapture costs 100–130 ms and stalls the next frame), and scene loads with <see cref="LoadTail"/> after.</summary>
+    public sealed class Exclusions
+    {
+        public int WarmupFrames;
+        public int CaptureTail = 4;
+        public int LoadTail = 2;
+        int start = int.MinValue / 2;
+        int openLoad = -1;
+        readonly List<int> from = new List<int>(), to = new List<int>();
+        readonly List<Skip> why = new List<Skip>();
+
+        public Exclusions(int warmupFrames = 0) { WarmupFrames = Math.Max(0, warmupFrames); }
+
+        /// <summary>The first frame measured: the warm-up counts from here.</summary>
+        public void Start(int frame) { start = frame; from.Clear(); to.Clear(); why.Clear(); openLoad = -1; }
+
+        public void Capture(int frame) => Add(frame, frame + CaptureTail, Skip.Capture);
+
+        public void LoadBegin(int frame) { if (openLoad < 0) openLoad = frame; }
+
+        public void LoadEnd(int frame)
+        {
+            if (openLoad < 0) return;
+            Add(openLoad, frame + LoadTail, Skip.Load);
+            openLoad = -1;
+        }
+
+        public bool Loading => openLoad >= 0;
+
+        void Add(int a, int b, Skip w)
+        {
+            int last = from.Count - 1;
+            // A run of captures (a recording) is one range, so Of stays short.
+            if (last >= 0 && why[last] == w && a <= to[last] + 1 && b >= from[last]) { from[last] = Math.Min(from[last], a); to[last] = Math.Max(to[last], b); return; }
+            from.Add(a); to.Add(b); why.Add(w);
+        }
+
+        public Skip Of(int frame)
+        {
+            Skip found = Skip.None;
+            for (int i = from.Count - 1; i >= 0; i--)
+            {
+                if (frame < from[i] || frame > to[i]) continue;
+                if (why[i] == Skip.Capture) return Skip.Capture;
+                found = why[i];
+            }
+            if (found != Skip.None) return found;
+            if (openLoad >= 0 && frame >= openLoad) return Skip.Load;
+            if (frame < start + WarmupFrames) return Skip.Warmup;
+            return Skip.None;
+        }
+    }
+
+    /// <summary>A distribution: count, mean, p50, p95, p99, max.</summary>
+    public struct Dist
+    {
+        public int N;
+        public double Mean, P50, P95, P99, Max;
+    }
+
+    public static class Stats
+    {
+        /// <summary>Nearest-rank percentile of the first <paramref name="n"/> values of a sorted array (q in 0..1):
+        /// the smallest value with at least q of the values at or below it. The same rule as funtools' report.ts.</summary>
+        public static double Percentile(double[] sorted, int n, double q)
+        {
+            if (n <= 0) return double.NaN;
+            int i = (int)Math.Ceiling(q * n) - 1;
+            if (i < 0) i = 0;
+            if (i > n - 1) i = n - 1;
+            return sorted[i];
+        }
+
+        /// <summary>The distribution of the values that were observed (0 or more); null when none were.</summary>
+        public static Dist? Of(List<double> values)
+        {
+            int n = 0;
+            var a = new double[values.Count];
+            double sum = 0;
+            foreach (var v in values) { if (v < 0 || double.IsNaN(v)) continue; a[n++] = v; sum += v; }
+            if (n == 0) return null;
+            Array.Sort(a, 0, n);
+            return new Dist { N = n, Mean = sum / n, P50 = Percentile(a, n, 0.50), P95 = Percentile(a, n, 0.95), P99 = Percentile(a, n, 0.99), Max = a[n - 1] };
+        }
+    }
+
+    /// <summary>What a report is built from.</summary>
+    public sealed class ReportInput
+    {
+        public FrameSample[] Samples;
+        public int Count;
+        public bool Truncated;
+        /// <summary>A frame longer than this (ms) is a hitch.</summary>
+        public double HitchMs = 33.3;
+        public List<string> Segments = new List<string> { "run" };
+        public int MaxHitches = 200;
+        /// <summary>Every frame as a row (funtools reads them for the host flags); off for a short summary.</summary>
+        public bool Rows = true;
+        /// <summary>Platform, device, screen, Unity version…: copied into the report as they are.</summary>
+        public Dictionary<string, object> Meta = new Dictionary<string, object>();
+        /// <summary>The counter each column was read from, or null when the player has none (not observed).</summary>
+        public Dictionary<string, object> Counters = new Dictionary<string, object>();
+    }
+
+    public static class ProbeReport
+    {
+        public const string Schema = "funpixel.probe/1";
+        public static readonly string[] Columns = { "frame", "segment", "skip", "ms", "main", "render", "work", "game_work", "gpu", "gc", "draws", "setpass", "batches", "tris" };
+
+        static double R(double v) => Math.Round(v, 3);
+
+        public static object DistJson(Dist? d)
+        {
+            if (!d.HasValue) return null;
+            var x = d.Value;
+            return new Dictionary<string, object> { { "n", x.N }, { "mean", R(x.Mean) }, { "p50", R(x.P50) }, { "p95", R(x.P95) }, { "p99", R(x.P99) }, { "max", R(x.Max) } };
+        }
+
+        /// <summary>The row's skip code, by index.</summary>
+        public static readonly string[] SkipNames = { "none", "warmup", "capture", "load" };
+
+        static Dictionary<string, object> FrameJson(FrameSample s, List<string> segments)
+        {
+            var o = new Dictionary<string, object>
+            {
+                { "frame", s.Frame }, { "ms", R(s.Ms) },
+                { "main", s.Main < 0 ? null : (object)R(s.Main) }, { "render", s.Render < 0 ? null : (object)R(s.Render) },
+                { "work", s.Work < 0 ? null : (object)R(s.Work) }, { "game_work", s.GameWork < 0 ? null : (object)R(s.GameWork) },
+                { "gpu", s.Gpu < 0 ? null : (object)R(s.Gpu) }, { "gc", s.Gc < 0 ? null : (object)s.Gc },
+                { "segment", s.Segment >= 0 && s.Segment < segments.Count ? segments[s.Segment] : null },
+            };
+            if (!string.IsNullOrEmpty(s.Note)) o["note"] = s.Note;
+            return o;
+        }
+
+        public static Dictionary<string, object> Build(ReportInput r)
+        {
+            var segs = r.Segments.Count > 0 ? r.Segments : new List<string> { "run" };
+            var ms = new List<double>(); var main = new List<double>(); var render = new List<double>(); var work = new List<double>();
+            var game = new List<double>(); var gpu = new List<double>(); var gc = new List<double>(); var draws = new List<double>();
+            var setpass = new List<double>(); var batches = new List<double>(); var tris = new List<double>();
+            var segMs = new List<List<double>>(); var segHitch = new int[segs.Count];
+            for (int i = 0; i < segs.Count; i++) segMs.Add(new List<double>());
+            int warm = 0, cap = 0, load = 0, gcFrames = 0, hitchCount = 0;
+            double warmMax = -1, loadMax = -1;
+            long gcTotal = 0, memPeak = -1, memLast = -1, sysPeak = -1, gcPeak = -1;
+            var hitches = new List<object>();
+            var included = new List<int>();
+            for (int i = 0; i < r.Count; i++)
+            {
+                var s = r.Samples[i];
+                if (s.MemTotal >= 0) { memPeak = Math.Max(memPeak, s.MemTotal); memLast = s.MemTotal; }
+                if (s.MemSystem >= 0) sysPeak = Math.Max(sysPeak, s.MemSystem);
+                if (s.MemGc >= 0) gcPeak = Math.Max(gcPeak, s.MemGc);
+                if (s.Skip == Skip.Warmup) { warm++; warmMax = Math.Max(warmMax, s.Ms); continue; }
+                if (s.Skip == Skip.Capture) { cap++; continue; }
+                if (s.Skip == Skip.Load) { load++; loadMax = Math.Max(loadMax, s.Ms); continue; }
+                included.Add(i);
+                ms.Add(s.Ms); main.Add(s.Main); render.Add(s.Render); work.Add(s.Work); game.Add(s.GameWork); gpu.Add(s.Gpu);
+                gc.Add(s.Gc); draws.Add(s.Draws); setpass.Add(s.SetPass); batches.Add(s.Batches); tris.Add(s.Tris);
+                if (s.Gc > 0) { gcFrames++; gcTotal += s.Gc; }
+                int seg = s.Segment >= 0 && s.Segment < segs.Count ? s.Segment : 0;
+                segMs[seg].Add(s.Ms);
+                if (s.Ms > r.HitchMs)
+                {
+                    hitchCount++; segHitch[seg]++;
+                    if (hitches.Count < r.MaxHitches) hitches.Add(FrameJson(s, segs));
+                }
+            }
+            // The five longest frames measured, longest first, whatever the threshold.
+            included.Sort((a, b) => r.Samples[b].Ms.CompareTo(r.Samples[a].Ms));
+            var worst = new List<object>();
+            for (int k = 0; k < included.Count && k < 5; k++) worst.Add(FrameJson(r.Samples[included[k]], segs));
+
+            var segments = new List<object>();
+            for (int i = 0; i < segs.Count; i++)
+                segments.Add(new Dictionary<string, object> { { "label", segs[i] }, { "frames", segMs[i].Count }, { "frame_ms", DistJson(Stats.Of(segMs[i])) }, { "hitches", segHitch[i] } });
+
+            const double MB = 1024.0 * 1024.0;
+            var o = new Dictionary<string, object>
+            {
+                { "schema", Schema },
+                { "meta", r.Meta },
+                { "counters", r.Counters },
+                { "frames", new Dictionary<string, object> {
+                    { "sampled", r.Count }, { "included", included.Count }, { "truncated", r.Truncated },
+                    { "excluded", new Dictionary<string, object> { { "warmup", warm }, { "capture", cap }, { "load", load } } } } },
+                { "hitch_ms", R(r.HitchMs) },
+                { "frame_ms", DistJson(Stats.Of(ms)) },
+                { "main_ms", DistJson(Stats.Of(main)) },
+                { "render_ms", DistJson(Stats.Of(render)) },
+                { "work_ms", DistJson(Stats.Of(work)) },
+                { "game_work_ms", DistJson(Stats.Of(game)) },
+                { "gpu_ms", DistJson(Stats.Of(gpu)) },
+                { "gc_bytes", DistJson(Stats.Of(gc)) },
+                { "gc_frames", gcFrames },
+                { "gc_total_bytes", gcTotal },
+                { "draws", DistJson(Stats.Of(draws)) },
+                { "setpass", DistJson(Stats.Of(setpass)) },
+                { "batches", DistJson(Stats.Of(batches)) },
+                { "triangles", DistJson(Stats.Of(tris)) },
+                { "memory_mb", new Dictionary<string, object> {
+                    { "total_used_peak", memPeak < 0 ? null : (object)R(memPeak / MB) }, { "total_used_last", memLast < 0 ? null : (object)R(memLast / MB) },
+                    { "system_used_peak", sysPeak < 0 ? null : (object)R(sysPeak / MB) }, { "gc_used_peak", gcPeak < 0 ? null : (object)R(gcPeak / MB) } } },
+                { "warmup_max_ms", warmMax < 0 ? null : (object)R(warmMax) },
+                { "load_max_ms", loadMax < 0 ? null : (object)R(loadMax) },
+                { "hitch_count", hitchCount },
+                { "hitches", hitches },
+                { "worst", worst },
+                { "segments", segments },
+            };
+            if (r.Rows)
+            {
+                var rows = new List<object>(r.Count);
+                for (int i = 0; i < r.Count; i++)
+                {
+                    var s = r.Samples[i];
+                    rows.Add(new object[] { s.Frame, s.Segment, (int)s.Skip, R(s.Ms), R(s.Main), R(s.Render), R(s.Work), R(s.GameWork), R(s.Gpu), s.Gc, s.Draws, s.SetPass, s.Batches, s.Tris });
+                }
+                o["columns"] = Columns;
+                o["skips"] = SkipNames;
+                o["rows"] = rows;
+            }
+            return o;
+        }
+    }
+}

package/unity/com.funpixel.probe/Runtime/Player/Stats.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 018aef8148465016d3e603f32efb7e9e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/unity/com.funpixel.probe/Runtime/Player/UiTargets.cs

@@ -0,0 +1,134 @@
+// What a finger can press on screen, as rects in screen pixels (Unity's bottom-left origin): the game's registered
+// targets (FunpixelProbe.Target) and every interactable UGUI Selectable with its name, hierarchy path and text. The
+// text is read from any child component with a string `text` property (UGUI Text, TextMeshPro), so the package needs
+// no TextMeshPro reference. Generalised from one game's remote-play UI targets.
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEngine;
+#if FUNPIXEL_UGUI
+using UnityEngine.UI;
+#endif
+
+namespace Funpixel.Probe
+{
+    internal struct UiTarget
+    {
+        public string Kind, Name, Path, Text;
+        public Rect Px;
+        public float Alpha;
+    }
+
+    internal static class UiTargets
+    {
+        static readonly Dictionary<Type, PropertyInfo> textProp = new Dictionary<Type, PropertyInfo>();
+        static readonly Vector3[] corners = new Vector3[4];
+
+        public static List<UiTarget> All()
+        {
+            var o = new List<UiTarget>();
+            foreach (var kv in FunpixelProbe.Targets)
+            {
+                Rect r;
+                try { r = kv.Value(); } catch (Exception) { continue; }
+                if (r.width <= 0 || r.height <= 0) continue;
+                o.Add(new UiTarget { Kind = "target", Name = kv.Key, Path = kv.Key, Px = r, Alpha = 1 });
+            }
+#if FUNPIXEL_UGUI
+#pragma warning disable CS0618 // the sort-mode overload is the one every Unity from 2022.3 has; 6.6 deprecates it
+            var found = UnityEngine.Object.FindObjectsByType<Selectable>(FindObjectsSortMode.None);
+#pragma warning restore CS0618
+            foreach (var s in found)
+            {
+                if (!s.isActiveAndEnabled || !s.IsInteractable()) continue;
+                float alpha = Alpha(s);
+                if (alpha <= 0.01f) continue;
+                if (!(s.transform is RectTransform rt) || !ScreenRect(rt, out var r)) continue;
+                o.Add(new UiTarget { Kind = s.GetType().Name.ToLowerInvariant(), Name = s.name, Path = PathOf(s.transform), Text = TextOf(s), Px = r, Alpha = alpha });
+            }
+#endif
+            return o;
+        }
+
+        static string PathOf(Transform t)
+        {
+            var parts = new List<string>();
+            for (var p = t; p != null; p = p.parent) parts.Add(p.name);
+            parts.Reverse();
+            return string.Join("/", parts);
+        }
+
+#if FUNPIXEL_UGUI
+        static float Alpha(Component c)
+        {
+            float k = 1;
+            foreach (var g in c.GetComponentsInParent<CanvasGroup>())
+            {
+                k *= g.alpha;
+                if (!g.blocksRaycasts || !g.interactable) k = 0;
+                if (g.ignoreParentGroups) break;
+            }
+            return k;
+        }
+
+        static bool ScreenRect(RectTransform rt, out Rect r)
+        {
+            r = default;
+            var canvas = rt.GetComponentInParent<Canvas>();
+            if (canvas == null) return false;
+            var root = canvas.rootCanvas;
+            Camera cam = root.renderMode == RenderMode.ScreenSpaceOverlay ? null : root.worldCamera;
+            rt.GetWorldCorners(corners);
+            var a = RectTransformUtility.WorldToScreenPoint(cam, corners[0]);
+            var b = RectTransformUtility.WorldToScreenPoint(cam, corners[2]);
+            r = Rect.MinMaxRect(Mathf.Min(a.x, b.x), Mathf.Min(a.y, b.y), Mathf.Max(a.x, b.x), Mathf.Max(a.y, b.y));
+            return r.width > 0 && r.xMax >= 0 && r.yMax >= 0 && r.xMin <= Screen.width && r.yMin <= Screen.height;
+        }
+#endif
+
+        static string TextOf(Component c)
+        {
+            foreach (var comp in c.GetComponentsInChildren<Component>(true))
+            {
+                if (comp == null) continue;
+                var t = comp.GetType();
+                if (!textProp.TryGetValue(t, out var p))
+                {
+                    p = t.Name.IndexOf("Text", StringComparison.Ordinal) >= 0 ? t.GetProperty("text", BindingFlags.Public | BindingFlags.Instance) : null;
+                    if (p != null && p.PropertyType != typeof(string)) p = null;
+                    textProp[t] = p;
+                }
+                if (p == null) continue;
+                try { var s = p.GetValue(comp) as string; if (!string.IsNullOrEmpty(s)) return s.Trim(); } catch (Exception) { }
+            }
+            return null;
+        }
+
+        /// <summary>The target a name means: a registered target, then a UI element by name, by path end, by its text,
+        /// then by text that contains it (all ignoring case). Null with the near names when nothing matches.</summary>
+        public static UiTarget? Find(string want, List<UiTarget> all, out string why)
+        {
+            why = null;
+            string w = (want ?? "").Trim();
+            Func<UiTarget, bool>[] rules =
+            {
+                t => t.Kind == "target" && string.Equals(t.Name, w, StringComparison.OrdinalIgnoreCase),
+                t => string.Equals(t.Name, w, StringComparison.OrdinalIgnoreCase),
+                t => t.Path != null && (string.Equals(t.Path, w, StringComparison.OrdinalIgnoreCase) || t.Path.EndsWith("/" + w, StringComparison.OrdinalIgnoreCase)),
+                t => t.Text != null && string.Equals(t.Text, w, StringComparison.OrdinalIgnoreCase),
+                t => t.Text != null && w.Length >= 2 && t.Text.IndexOf(w, StringComparison.OrdinalIgnoreCase) >= 0,
+            };
+            foreach (var rule in rules)
+            {
+                UiTarget? hit = null;
+                int n = 0;
+                foreach (var t in all) if (rule(t)) { n++; if (hit == null || t.Alpha > hit.Value.Alpha) hit = t; }
+                if (n >= 1) { if (n > 1) why = $"{n} targets match \"{w}\"; pressed the most visible ({hit.Value.Path})"; return hit; }
+            }
+            var near = new List<string>();
+            foreach (var t in all) { near.Add(t.Text != null ? $"{t.Name} \"{t.Text}\"" : t.Name); if (near.Count >= 12) break; }
+            why = near.Count == 0 ? "nothing on screen can be pressed" : "on screen: " + string.Join(", ", near);
+            return null;
+        }
+    }
+}

package/unity/com.funpixel.probe/Runtime/Player/UiTargets.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 576a62e92165d828510b14c452a588a7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/unity/com.funpixel.probe/Runtime/Player.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5701fa255afc92958b8a07fe14d1402e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/unity/com.funpixel.probe/Runtime/link.xml

@@ -0,0 +1,7 @@
+<!-- Keeps the probe whole under IL2CPP's managed code stripping: the player assembly boots itself and nothing in a
+     game references it, so the linker would drop it. Development builds only: the player assembly's
+     define constraints already leave it out of a release build, and ignoreIfMissing lets that build pass. -->
+<linker>
+  <assembly fullname="Funpixel.Probe.Player" preserve="all" ignoreIfMissing="1"/>
+  <assembly fullname="Funpixel.Probe" preserve="all" ignoreIfMissing="1"/>
+</linker>

package/unity/com.funpixel.probe/Runtime/link.xml.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 92d57c73d57e438b8130d446f3e217ba
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/unity/com.funpixel.probe/Runtime.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6aa1869f69531b4e915c0656f3e2ee2f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: