@funpixel/tools 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,559 @@
+// The player bridge: a TCP server on 127.0.0.1 inside a development player (an iOS Simulator shares the Mac's network,
+// so funtools on the Mac reaches a Simulator's player the same way). Lifted from one game's remote-play server (the
+// owner's, 661 lines with a Python driver) and made game-agnostic: the game's own facts,
+// targets, views and commands come in through FunpixelProbe; the rest is here.
+//
+// One JSON object per line in ({"cmd": "tap", "x": 100, "y": 200, "id": 7}), one JSON reply per line out
+// ({"ok": true, "id": 7, …} or {"ok": false, "error": "…"}). A command that takes time (a drag, a hold, a wait, a scene
+// load) replies when it is done; with "async": true it replies at once and runs on (a stick held while a button is tapped).
+//
+// Coordinates are points from the top-left of the game's own screen, so a landscape game is landscape here whatever way
+// a Simulator holds its framebuffer; "space": "px" takes the screen's pixels from the top-left (a still's own pixels).
+//
+// Commands: ping, screen, tap, hold, drag, touch, key, pad, release, wait, frames, state, ui, views, view, scene, shot,
+// record, speed, probe.start, probe.segment, probe.report, probe.stop, probe.write, quit, and any FunpixelProbe.Command.
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+#if FUNPIXEL_INPUT_SYSTEM
+using TouchPhase = UnityEngine.InputSystem.TouchPhase;
+#endif
+
+namespace Funpixel.Probe
+{
+    [DefaultExecutionOrder(-31000)]
+    public sealed class Bridge : MonoBehaviour
+    {
+        public const int DefaultPort = 7541;
+        public const string Version = "0.1.0";
+        public static Bridge Instance { get; private set; }
+        public int Port { get; private set; }
+
+        sealed class Client
+        {
+            public TcpClient Tcp;
+            public StreamWriter W;
+            public readonly object Gate = new object();
+            public int Id;
+            public void Send(string line)
+            {
+                try { lock (Gate) { W.Write(line); W.Write('\n'); W.Flush(); } }
+                catch (Exception) { /* the client went away */ }
+            }
+        }
+
+        TcpListener listener;
+        volatile bool running;
+        int clients;
+        readonly ConcurrentQueue<(Client c, string line)> inbox = new ConcurrentQueue<(Client, string)>();
+        float fps = 60;
+#if FUNPIXEL_INPUT_SYSTEM
+        readonly Inject input = new Inject();
+#endif
+
+        public static Bridge Listen(GameObject host, int port)
+        {
+            if (Instance != null) return Instance;
+            Instance = host.AddComponent<Bridge>();
+            Instance.Open(port);
+            return Instance;
+        }
+
+        void Open(int port)
+        {
+            Port = port;
+            try
+            {
+                listener = new TcpListener(IPAddress.Loopback, port);
+                listener.Start();
+                Port = ((IPEndPoint)listener.LocalEndpoint).Port;
+            }
+            catch (Exception e) { Debug.LogError($"[FunpixelProbe] can't listen on 127.0.0.1:{port}: {e.Message}"); return; }
+            running = true;
+            new Thread(AcceptLoop) { IsBackground = true, Name = "funpixel-probe accept" }.Start();
+            Debug.Log($"[FunpixelProbe] listening on 127.0.0.1:{Port}");
+        }
+
+        void AcceptLoop()
+        {
+            while (running)
+            {
+                TcpClient tcp;
+                try { tcp = listener.AcceptTcpClient(); }
+                catch (Exception) { if (!running) return; continue; }
+                tcp.NoDelay = true;
+                var c = new Client { Tcp = tcp, W = new StreamWriter(tcp.GetStream(), new UTF8Encoding(false)), Id = Interlocked.Increment(ref clients) };
+                new Thread(() => ReadLoop(c)) { IsBackground = true, Name = "funpixel-probe client " + c.Id }.Start();
+            }
+        }
+
+        void ReadLoop(Client c)
+        {
+            try
+            {
+                using (var r = new StreamReader(c.Tcp.GetStream(), Encoding.UTF8))
+                {
+                    string line;
+                    while (running && (line = r.ReadLine()) != null)
+                        if (line.Trim().Length > 0) inbox.Enqueue((c, line));
+                }
+            }
+            catch (Exception) { }
+            finally { try { c.Tcp.Close(); } catch (Exception) { } }
+        }
+
+        void OnDestroy()
+        {
+            running = false;
+            try { listener?.Stop(); } catch (Exception) { }
+            if (Instance == this) Instance = null;
+        }
+
+        void Update()
+        {
+            float dt = Time.unscaledDeltaTime;
+            if (dt > 0) fps += (1f / dt - fps) * Mathf.Min(1, dt * 2);
+            while (inbox.TryDequeue(out var m)) Handle(m.c, m.line);
+        }
+
+        // ── dispatch ──
+
+        void Handle(Client c, string line)
+        {
+            Dictionary<string, object> a;
+            try { a = Json.Parse(line) as Dictionary<string, object>; }
+            catch (Exception e) { c.Send(Err(null, "bad json: " + e.Message)); return; }
+            if (a == null) { c.Send(Err(null, "expected a JSON object")); return; }
+            object id = a.TryGetValue("id", out var v) ? v : null;
+            string cmd = Json.S(a, "cmd");
+            if (cmd == null) { c.Send(Err(id, "no \"cmd\"")); return; }
+            IEnumerator job;
+            try { job = Run(cmd, a, id); }
+            catch (Exception e) { c.Send(Err(id, e.GetType().Name + ": " + e.Message)); return; }
+            if (Json.B(a, "async"))
+            {
+                c.Send(Ok(id, ("started", cmd)));
+                StartCoroutine(Guard(job, _ => { }, cmd, id));
+            }
+            else StartCoroutine(Guard(job, c.Send, cmd, id));
+        }
+
+        /// <summary>Runs a command's job, turning an exception into an error reply.</summary>
+        IEnumerator Guard(IEnumerator job, Action<string> send, string cmd, object id)
+        {
+            while (true)
+            {
+                object cur;
+                try
+                {
+                    if (!job.MoveNext()) { send(Ok(id)); yield break; }
+                    cur = job.Current;
+                }
+                catch (Exception e) { send(Err(id, cmd + ": " + e.GetType().Name + ": " + e.Message)); yield break; }
+                if (cur is Reply reply) { send(reply.Line); yield break; }
+                yield return cur;
+            }
+        }
+
+        sealed class Reply { public string Line; public Reply(string l) { Line = l; } }
+
+        static IEnumerator WaitMs(double ms)
+        {
+            for (double t0 = Time.realtimeSinceStartupAsDouble; (Time.realtimeSinceStartupAsDouble - t0) * 1000 < ms;) yield return null;
+        }
+
+        /// <summary>A command's job: yields null (or a nested wait) to let frames pass; yields a Reply to finish.</summary>
+        IEnumerator Run(string cmd, Dictionary<string, object> a, object id)
+        {
+            switch (cmd)
+            {
+                case "ping":
+                    yield return new Reply(Ok(id, ("pong", true), ("version", Version), ("platform", Application.platform.ToString()), ("frame", Time.frameCount),
+                        ("probe", Probe.Instance != null && Probe.Instance.Running), ("input", InputAvailable), ("product", Application.productName)));
+                    break;
+                case "screen": yield return new Reply(ScreenInfo(id)); break;
+                case "wait":
+                {
+                    double ms = Json.D(a, "ms", 500);
+                    yield return WaitMs(ms);
+                    yield return new Reply(Ok(id, ("ms", ms)));
+                    break;
+                }
+                case "frames":
+                {
+                    int n = Math.Max(1, Json.I(a, "n", 1)), f0 = Time.frameCount;
+                    while (Time.frameCount - f0 < n) yield return null;
+                    yield return new Reply(Ok(id, ("frames", Time.frameCount - f0)));
+                    break;
+                }
+                case "state": yield return new Reply(State(id)); break;
+                case "ui": yield return new Reply(Ui(id)); break;
+                case "views": yield return new Reply(Views(id)); break;
+                case "view":
+                {
+                    string name = Json.S(a, "name");
+                    var entry = FunpixelProbe.Views.Find(x => string.Equals(x.Name, name, StringComparison.OrdinalIgnoreCase));
+                    if (entry != null)
+                    {
+                        entry.Enter();
+                        int settle = Json.I(a, "settle", entry.SettleFrames);
+                        for (int i = 0; i < settle; i++) yield return null;
+                        yield return new Reply(Ok(id, ("view", entry.Name), ("scene", SceneManager.GetActiveScene().name)));
+                        break;
+                    }
+                    int index = SceneIndex(name);
+                    if (index < 0) { yield return new Reply(Err(id, $"no view or build scene \"{name}\" (views lists them)")); break; }
+                    foreach (var y in LoadScene(index, false)) yield return y;
+                    for (int i = 0; i < Json.I(a, "settle", 10); i++) yield return null;
+                    yield return new Reply(Ok(id, ("view", name), ("scene", SceneManager.GetActiveScene().name)));
+                    break;
+                }
+                case "scene":
+                {
+                    int index = Json.Has(a, "index") ? Json.I(a, "index", -1) : SceneIndex(Json.S(a, "name"));
+                    if (index < 0 || index >= SceneManager.sceneCountInBuildSettings) { yield return new Reply(Err(id, $"no build scene {Json.S(a, "name") ?? Json.S(a, "index")}")); break; }
+                    double t0 = Time.realtimeSinceStartupAsDouble;
+                    foreach (var y in LoadScene(index, Json.B(a, "additive"))) yield return y;
+                    yield return new Reply(Ok(id, ("scene", SceneManager.GetActiveScene().name), ("index", index), ("ms", Math.Round((Time.realtimeSinceStartupAsDouble - t0) * 1000, 1))));
+                    break;
+                }
+                case "speed":
+                    if (Json.Has(a, "x")) Time.timeScale = (float)Math.Max(0, Math.Min(8, Json.D(a, "x", 1)));
+                    yield return new Reply(Ok(id, ("speed", Time.timeScale)));
+                    break;
+                case "shot":
+                {
+                    byte[] png = null; int w = 0, h = 0;
+                    yield return Capture.Still(Json.I(a, "scale", 1), (b, x, y) => { png = b; w = x; h = y; });
+                    string path = Json.S(a, "path");
+                    string full = null;
+                    if (path != null)
+                    {
+                        full = Path.IsPathRooted(path) ? path : Path.Combine(Application.persistentDataPath, path);
+                        Directory.CreateDirectory(Path.GetDirectoryName(full));
+                        File.WriteAllBytes(full, png);
+                    }
+                    var fields = new List<(string, object)> { ("w", w), ("h", h), ("bytes", png.Length), ("scene", SceneManager.GetActiveScene().name), ("frame", Time.frameCount) };
+                    if (full != null) fields.Add(("path", full));
+                    if (full == null || Json.B(a, "inline")) fields.Add(("png", Convert.ToBase64String(png)));
+                    yield return new Reply(Ok(id, fields.ToArray()));
+                    break;
+                }
+                case "record":
+                {
+                    string dir = Json.S(a, "dir") ?? Path.Combine(Application.persistentDataPath, "funpixel-record-" + DateTime.Now.ToString("HHmmss"));
+                    if (!Path.IsPathRooted(dir)) dir = Path.Combine(Application.persistentDataPath, dir);
+                    Dictionary<string, object> got = null;
+                    yield return Capture.Record(dir, Json.D(a, "seconds", 5), Json.I(a, "fps", 30), !Json.Has(a, "audio") || Json.B(a, "audio"), Json.I(a, "scale", 1), Json.I(a, "quality", 90), r => got = r);
+                    var o = new List<(string, object)>();
+                    foreach (var kv in got) o.Add((kv.Key, kv.Value));
+                    yield return new Reply(Ok(id, o.ToArray()));
+                    break;
+                }
+                case "probe.start":
+                {
+                    var p = Probe.Ensure(gameObject);
+                    if (Json.Has(a, "hitch_ms")) p.HitchMs = Json.D(a, "hitch_ms", -1);
+                    p.Begin(Json.I(a, "warmup", 0), Json.I(a, "capacity", Probe.DefaultCapacity));
+                    if (Json.S(a, "label") != null) p.Segment(Json.S(a, "label"));
+                    yield return null;
+                    yield return new Reply(Ok(id, ("probe", true), ("frame", Time.frameCount), ("hitch_ms", p.HitchMs)));
+                    break;
+                }
+                case "probe.segment":
+                {
+                    if (Probe.Instance == null) { yield return new Reply(Err(id, "the probe is not running (probe.start, or launch with -fp-probe)")); break; }
+                    int n = Probe.Instance.Segment(Json.S(a, "label"));
+                    yield return new Reply(Ok(id, ("segment", n), ("frame", Time.frameCount)));
+                    break;
+                }
+                case "probe.stop":
+                    if (Probe.Instance != null) Probe.Instance.Stop();
+                    yield return new Reply(Ok(id, ("probe", false)));
+                    break;
+                case "probe.report":
+                {
+                    if (Probe.Instance == null) { yield return new Reply(Err(id, "the probe is not running (probe.start, or launch with -fp-probe)")); break; }
+                    var r = Probe.Instance.Report(!Json.Has(a, "rows") || Json.B(a, "rows"));
+                    r["ok"] = true;
+                    if (id != null) r["id"] = id;
+                    yield return new Reply(Json.Write(r));
+                    break;
+                }
+                case "probe.write":
+                {
+                    if (Probe.Instance == null) { yield return new Reply(Err(id, "the probe is not running")); break; }
+                    string path = Json.S(a, "path") ?? Path.Combine(Application.persistentDataPath, "funpixel-probe.json");
+                    if (!Path.IsPathRooted(path)) path = Path.Combine(Application.persistentDataPath, path);
+                    File.WriteAllText(path, Json.Write(Probe.Instance.Report(true)));
+                    yield return new Reply(Ok(id, ("path", path)));
+                    break;
+                }
+                case "quit":
+                    // The reply goes out first; the player quits two frames later.
+                    StartCoroutine(QuitSoon());
+                    yield return new Reply(Ok(id, ("quitting", true)));
+                    break;
+#if FUNPIXEL_INPUT_SYSTEM
+                case "touch":
+                {
+                    int tid = Json.I(a, "touch", 1);
+                    var phase = Json.S(a, "phase") ?? "down";
+                    var p = Px(a, Json.D(a, "x"), Json.D(a, "y"));
+                    input.Touch(tid, phase == "down" ? TouchPhase.Began : phase == "up" ? TouchPhase.Ended : phase == "cancel" ? TouchPhase.Canceled : TouchPhase.Moved, p);
+                    yield return null;
+                    yield return new Reply(Ok(id, ("touch", tid), ("phase", phase), ("at", Pt(p))));
+                    break;
+                }
+                case "tap":
+                case "hold":
+                {
+                    var p = Target(a, out string note);
+                    double ms = Json.D(a, "ms", cmd == "tap" ? 80 : 500);
+                    bool mouse = Json.S(a, "device") == "mouse";
+                    int tid = input.NewTouchId();
+                    if (mouse) { input.Mouse(p, false); yield return null; input.Mouse(p, true); }
+                    else input.Touch(tid, TouchPhase.Began, p);
+                    yield return null;
+                    yield return WaitMs(ms);
+                    if (mouse) input.Mouse(p, false); else input.Touch(tid, TouchPhase.Ended, p);
+                    yield return null;
+                    yield return new Reply(Ok(id, ("at", Pt(p)), ("px", new[] { Math.Round(p.x, 1), Math.Round(Screen.height - p.y, 1) }), ("ms", ms), ("note", note)));
+                    break;
+                }
+                case "drag":
+                {
+                    var f = Json.Pair(a, "from"); var t = Json.Pair(a, "to");
+                    if (f == null || t == null) { yield return new Reply(Err(id, "drag needs \"from\": [x, y] and \"to\": [x, y]")); break; }
+                    var from = Px(a, f[0], f[1]); var to = Px(a, t[0], t[1]);
+                    double ms = Json.D(a, "ms", 300), hold = Json.D(a, "hold_ms", 0);
+                    bool mouse = Json.S(a, "device") == "mouse";
+                    int tid = input.NewTouchId();
+                    if (mouse) input.Mouse(from, true); else input.Touch(tid, TouchPhase.Began, from);
+                    yield return null;
+                    double t0 = Time.realtimeSinceStartupAsDouble;
+                    while (true)
+                    {
+                        float k = ms <= 0 ? 1 : Mathf.Clamp01((float)((Time.realtimeSinceStartupAsDouble - t0) * 1000 / ms));
+                        var at = Vector2.Lerp(from, to, k);
+                        if (mouse) input.Mouse(at, true); else input.Touch(tid, TouchPhase.Moved, at);
+                        yield return null;
+                        if (k >= 1) break;
+                    }
+                    yield return WaitMs(hold);
+                    if (mouse) input.Mouse(to, false); else input.Touch(tid, TouchPhase.Ended, to);
+                    yield return null;
+                    yield return new Reply(Ok(id, ("from", Pt(from)), ("to", Pt(to)), ("ms", ms)));
+                    break;
+                }
+                case "key":
+                {
+                    string name = Json.S(a, "name") ?? Json.S(a, "key");
+                    double ms = Json.D(a, "ms", 80);
+                    if (!input.Key(name, true)) { yield return new Reply(Err(id, "no key " + name + " (Unity's names: Space, LeftArrow, A; or the web's: ArrowLeft, KeyA, Digit1)")); break; }
+                    yield return null;
+                    yield return WaitMs(ms);
+                    input.Key(name, false);
+                    yield return null;
+                    yield return new Reply(Ok(id, ("key", Inject.KeyOf(name).ToString()), ("ms", ms)));
+                    break;
+                }
+                case "pad":
+                {
+                    double ms = Json.D(a, "ms", 80);
+                    string button = Json.S(a, "button");
+                    var b = button != null ? Inject.ButtonOf(button) : null;
+                    if (button != null && b == null) { yield return new Reply(Err(id, "no pad button " + button + " (south/a, east/b, west/x, north/y, start, select, lb, rb, lt, rt, ls, rs, up, down, left, right)")); break; }
+                    var stick = Json.Pair(a, "stick");
+                    if (b.HasValue) input.PadButton(b.Value, true);
+                    if (stick != null) input.PadStick(new Vector2((float)stick[0], (float)stick[1]));
+                    yield return null;
+                    yield return WaitMs(ms);
+                    if (b.HasValue) input.PadButton(b.Value, false);
+                    if (stick != null) input.PadStick(Vector2.zero);
+                    yield return null;
+                    yield return new Reply(Ok(id, ("pad", button ?? "stick"), ("ms", ms)));
+                    break;
+                }
+                case "release":
+                    input.ReleaseAll();
+                    yield return null;
+                    yield return new Reply(Ok(id));
+                    break;
+#else
+                case "touch": case "tap": case "hold": case "drag": case "key": case "pad": case "release":
+                    yield return new Reply(Err(id, "this player has no Input System package (com.unity.inputsystem), so the bridge cannot inject input"));
+                    break;
+#endif
+                default:
+                {
+                    if (FunpixelProbe.Commands.TryGetValue(cmd, out var run))
+                    {
+                        object value = run(a);
+                        yield return null;
+                        yield return new Reply(Ok(id, ("value", value)));
+                        break;
+                    }
+                    yield return new Reply(Err(id, "unknown cmd " + cmd));
+                    break;
+                }
+            }
+        }
+
+        static IEnumerator QuitSoon()
+        {
+            yield return null;
+            yield return null;
+            Application.Quit();
+        }
+
+#if FUNPIXEL_INPUT_SYSTEM
+        const bool InputAvailable = true;
+#else
+        const bool InputAvailable = false;
+#endif
+
+        // ── scenes ──
+
+        static int SceneIndex(string name)
+        {
+            if (string.IsNullOrEmpty(name)) return -1;
+            for (int i = 0; i < SceneManager.sceneCountInBuildSettings; i++)
+            {
+                string path = SceneUtility.GetScenePathByBuildIndex(i);
+                if (string.Equals(path, name, StringComparison.OrdinalIgnoreCase) || string.Equals(Path.GetFileNameWithoutExtension(path), name, StringComparison.OrdinalIgnoreCase)) return i;
+            }
+            return int.TryParse(name, NumberStyles.Integer, CultureInfo.InvariantCulture, out var n) && n >= 0 && n < SceneManager.sceneCountInBuildSettings ? n : -1;
+        }
+
+        IEnumerable LoadScene(int index, bool additive)
+        {
+            var p = Probe.Instance;
+            if (p != null) p.LoadBegin();
+            var op = SceneManager.LoadSceneAsync(index, additive ? LoadSceneMode.Additive : LoadSceneMode.Single);
+            while (op != null && !op.isDone) yield return null;
+            yield return null;
+            if (p != null) p.LoadEnd();
+        }
+
+        // ── coordinates: points from the top-left of the game's screen, or "space": "px" ──
+
+        /// <summary>Screen pixels per point: -fp-scale, else on iOS 3 (Screen.dpi 380 or more) or 2, else 1.</summary>
+        public static float Scale
+        {
+            get
+            {
+                double o = Args.Number("-fp-scale", 0);
+                if (o > 0) return (float)o;
+                if (Application.platform != RuntimePlatform.IPhonePlayer) return 1;
+                return Screen.dpi >= 380 ? 3 : 2;
+            }
+        }
+
+        static Vector2 Px(Dictionary<string, object> a, double x, double y)
+        {
+            float s = Json.S(a, "space") == "px" ? 1 : Scale;
+            return new Vector2((float)(x * s), Screen.height - (float)(y * s));
+        }
+
+        static double[] Pt(Vector2 px) { float s = Scale; return new[] { Math.Round(px.x / s, 1), Math.Round((Screen.height - px.y) / s, 1) }; }
+
+        static Dictionary<string, object> PtRect(Rect r)
+        {
+            float s = Scale;
+            return new Dictionary<string, object>
+            {
+                { "x", Math.Round(r.xMin / s, 1) }, { "y", Math.Round((Screen.height - r.yMax) / s, 1) },
+                { "w", Math.Round(r.width / s, 1) }, { "h", Math.Round(r.height / s, 1) },
+                { "cx", Math.Round(r.center.x / s, 1) }, { "cy", Math.Round((Screen.height - r.center.y) / s, 1) },
+            };
+        }
+
+        /// <summary>tap / hold at x, y, or at a named target (a registered target, a UI element by name, path or text).</summary>
+        static Vector2 Target(Dictionary<string, object> a, out string note)
+        {
+            note = null;
+            string t = Json.S(a, "target");
+            if (t == null) return Px(a, Json.D(a, "x"), Json.D(a, "y"));
+            var hit = UiTargets.Find(t, UiTargets.All(), out note);
+            if (hit == null) throw new ArgumentException($"no target \"{t}\" — {note}");
+            return hit.Value.Px.center;
+        }
+
+        // ── replies ──
+
+        string ScreenInfo(object id)
+        {
+            var sa = Screen.safeArea;
+            return Ok(id, ("px", new[] { Screen.width, Screen.height }), ("scale", Scale),
+                ("pt", new[] { Math.Round(Screen.width / Scale, 1), Math.Round(Screen.height / Scale, 1) }), ("safe", PtRect(sa)),
+                ("orientation", Screen.orientation.ToString()), ("dpi", Screen.dpi), ("refresh", Screen.currentResolution.refreshRateRatio.value),
+                ("target_fps", Application.targetFrameRate), ("platform", Application.platform.ToString()));
+        }
+
+        string State(object id)
+        {
+            var game = new Dictionary<string, object>();
+            foreach (var kv in FunpixelProbe.States)
+            {
+                try { game[kv.Key] = kv.Value(); }
+                catch (Exception e) { game[kv.Key] = "error: " + e.Message; }
+            }
+            return Ok(id, ("scene", SceneManager.GetActiveScene().name), ("frame", Time.frameCount), ("time", Math.Round(Time.time, 3)),
+                ("fps", Math.Round(fps, 1)), ("speed", Time.timeScale), ("game", game));
+        }
+
+        string Ui(object id)
+        {
+            var items = new List<object>();
+            foreach (var t in UiTargets.All())
+            {
+                var o = PtRect(t.Px);
+                o["kind"] = t.Kind; o["name"] = t.Name; o["path"] = t.Path;
+                if (t.Text != null) o["text"] = t.Text;
+                o["alpha"] = Math.Round(t.Alpha, 2);
+                items.Add(o);
+            }
+            return Ok(id, ("scale", Scale), ("targets", items));
+        }
+
+        string Views(object id)
+        {
+            var views = new List<object>();
+            foreach (var v in FunpixelProbe.Views) views.Add(v.Name);
+            var scenes = new List<object>();
+            for (int i = 0; i < SceneManager.sceneCountInBuildSettings; i++)
+            {
+                string path = SceneUtility.GetScenePathByBuildIndex(i);
+                scenes.Add(new Dictionary<string, object> { { "index", i }, { "name", Path.GetFileNameWithoutExtension(path) }, { "path", path } });
+            }
+            return Ok(id, ("views", views), ("scenes", scenes), ("active", SceneManager.GetActiveScene().name));
+        }
+
+        static string Ok(object id, params (string k, object v)[] kv)
+        {
+            var sb = new StringBuilder("{\"ok\":true");
+            if (id != null) { sb.Append(",\"id\":"); Json.Write(sb, id); }
+            foreach (var (k, v) in kv) { sb.Append(','); Json.Str(sb, k); sb.Append(':'); Json.Write(sb, v); }
+            return sb.Append('}').ToString();
+        }
+
+        static string Err(object id, string msg)
+        {
+            var sb = new StringBuilder("{\"ok\":false");
+            if (id != null) { sb.Append(",\"id\":"); Json.Write(sb, id); }
+            sb.Append(",\"error\":");
+            Json.Str(sb, msg);
+            return sb.Append('}').ToString();
+        }
+    }
+}

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

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