@funpixel/tools 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,145 @@
+// Pictures and sound from inside the player, so nothing is read off the screen of the Mac: a still is the frame the
+// game drew (ScreenCapture after the frame, overlay UI included, upright in the game's own orientation, whatever way
+// a Simulator is held), and a recording is frames plus the game's own mix. The recording follows one game's
+// recorder (the owner's): game time steps at the recording's rate (Time.captureFramerate) and Unity's offline
+// audio renderer (AudioRenderer) hands over exactly one frame's samples each frame, so picture and sound stay in step
+// however slowly the frames are written. funtools joins them with ffmpeg. Every capture frame is marked for the probe.
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using Unity.Collections;
+using UnityEngine;
+
+namespace Funpixel.Probe
+{
+    internal static class Capture
+    {
+        static void Mark() { if (Probe.Instance != null) Probe.Instance.MarkCapture(); }
+
+        // WaitForEndOfFrame never comes in a batch-mode player: there, capture at the next frame instead.
+        static object EndOfFrame() => Application.isBatchMode ? null : new WaitForEndOfFrame();
+
+        /// <summary>One still after this frame is drawn: PNG bytes, width, height.</summary>
+        public static IEnumerator Still(int superSize, Action<byte[], int, int> done)
+        {
+            yield return EndOfFrame();
+            Mark();
+            var tex = ScreenCapture.CaptureScreenshotAsTexture(Mathf.Clamp(superSize, 1, 4));
+            try { done(tex.EncodeToPNG(), tex.width, tex.height); }
+            finally { UnityEngine.Object.Destroy(tex); }
+        }
+
+        static int Channels(AudioSpeakerMode m)
+        {
+            switch (m)
+            {
+                case AudioSpeakerMode.Mono: return 1;
+                case AudioSpeakerMode.Quad: return 4;
+                case AudioSpeakerMode.Surround: return 5;
+                case AudioSpeakerMode.Mode5point1: return 6;
+                case AudioSpeakerMode.Mode7point1: return 8;
+                default: return 2;
+            }
+        }
+
+        /// <summary>A recording into <paramref name="dir"/>: f00000.jpg… at <paramref name="fps"/> and audio.wav (16-bit PCM,
+        /// the mixer's rate and channels) when <paramref name="audio"/>. Replies with what was written.</summary>
+        public static IEnumerator Record(string dir, double seconds, int fps, bool audio, int superSize, int quality, Action<Dictionary<string, object>> done)
+        {
+            Directory.CreateDirectory(dir);
+            fps = Mathf.Clamp(fps, 1, 60);
+            int total = Mathf.Max(1, (int)Math.Round(seconds * fps));
+            int rate = AudioSettings.outputSampleRate;
+            int channels = Channels(AudioSettings.GetConfiguration().speakerMode);
+            int was = Time.captureFramerate;
+            float volume = AudioListener.volume;
+            WavWriter wav = null;
+            string wavPath = Path.Combine(dir, "audio.wav");
+            int frames = 0, w = 0, h = 0;
+            long samples = 0;
+            string error = null;
+            Time.captureFramerate = fps;
+            if (audio)
+            {
+                // A probe run mutes the game for the person at the Mac (-fp-mute); the offline renderer takes the mix
+                // instead of the speakers, so the recording gets its sound back for its length.
+                AudioListener.volume = Probe.Instance != null || Args.Has("-fp-mute") ? 1 : volume;
+                try { wav = new WavWriter(wavPath, rate, channels); AudioRenderer.Start(); }
+                catch (Exception e) { error = "audio: " + e.Message; wav?.Dispose(); wav = null; }
+            }
+            try
+            {
+                while (frames < total)
+                {
+                    yield return EndOfFrame();
+                    Mark();
+                    var tex = ScreenCapture.CaptureScreenshotAsTexture(Mathf.Clamp(superSize, 1, 4));
+                    w = tex.width; h = tex.height;
+                    try { File.WriteAllBytes(Path.Combine(dir, "f" + frames.ToString("00000") + ".jpg"), tex.EncodeToJPG(Mathf.Clamp(quality, 50, 100))); }
+                    finally { UnityEngine.Object.Destroy(tex); }
+                    if (wav != null)
+                    {
+                        int n = AudioRenderer.GetSampleCountForCaptureFrame();
+                        if (n > 0)
+                        {
+                            var buf = new NativeArray<float>(n * channels, Allocator.Temp);
+                            try { if (AudioRenderer.Render(buf)) { wav.Write(buf); samples += n; } }
+                            finally { buf.Dispose(); }
+                        }
+                    }
+                    frames++;
+                }
+            }
+            finally
+            {
+                if (wav != null) { try { AudioRenderer.Stop(); } catch (Exception) { } wav.Dispose(); }
+                Time.captureFramerate = was;
+                AudioListener.volume = volume;
+            }
+            done(new Dictionary<string, object>
+            {
+                { "dir", dir }, { "frames", frames }, { "fps", fps }, { "w", w }, { "h", h }, { "pattern", "f%05d.jpg" },
+                { "audio", wav != null ? wavPath : null }, { "sample_rate", rate }, { "channels", channels }, { "samples", samples },
+                { "audio_error", error },
+            });
+        }
+
+        /// <summary>16-bit PCM WAV written as it comes, the header's sizes filled in at the end.</summary>
+        sealed class WavWriter : IDisposable
+        {
+            readonly FileStream f;
+            readonly BinaryWriter w;
+            readonly int channels;
+            long bytes;
+
+            public WavWriter(string path, int rate, int channels)
+            {
+                this.channels = channels;
+                f = File.Create(path);
+                w = new BinaryWriter(f);
+                w.Write(new[] { (byte)'R', (byte)'I', (byte)'F', (byte)'F' }); w.Write(0);
+                w.Write(new[] { (byte)'W', (byte)'A', (byte)'V', (byte)'E', (byte)'f', (byte)'m', (byte)'t', (byte)' ' });
+                w.Write(16); w.Write((short)1); w.Write((short)channels); w.Write(rate); w.Write(rate * channels * 2); w.Write((short)(channels * 2)); w.Write((short)16);
+                w.Write(new[] { (byte)'d', (byte)'a', (byte)'t', (byte)'a' }); w.Write(0);
+            }
+
+            public void Write(NativeArray<float> buf)
+            {
+                for (int i = 0; i < buf.Length; i++) w.Write((short)Mathf.Clamp(buf[i] * 32767f, -32768f, 32767f));
+                bytes += buf.Length * 2L;
+            }
+
+            public void Dispose()
+            {
+                try
+                {
+                    w.Flush();
+                    f.Seek(4, SeekOrigin.Begin); w.Write((int)(36 + bytes));
+                    f.Seek(40, SeekOrigin.Begin); w.Write((int)bytes);
+                }
+                finally { w.Dispose(); }
+            }
+        }
+    }
+}

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

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

package/unity/com.funpixel.probe/Runtime/Player/Funpixel.Probe.Player.asmdef

@@ -0,0 +1,32 @@
+{
+    "name": "Funpixel.Probe.Player",
+    "rootNamespace": "Funpixel.Probe",
+    "references": [
+        "Funpixel.Probe",
+        "Unity.InputSystem",
+        "UnityEngine.UI"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "DEVELOPMENT_BUILD || UNITY_EDITOR || FUNPIXEL_PROBE",
+        "!FUNPIXEL_NO_PROBE"
+    ],
+    "versionDefines": [
+        {
+            "name": "com.unity.inputsystem",
+            "expression": "1.0.0",
+            "define": "FUNPIXEL_INPUT_SYSTEM"
+        },
+        {
+            "name": "com.unity.ugui",
+            "expression": "1.0.0",
+            "define": "FUNPIXEL_UGUI"
+        }
+    ],
+    "noEngineReferences": false
+}

package/unity/com.funpixel.probe/Runtime/Player/Funpixel.Probe.Player.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d780f21d1d11de7f6cc557d3a24d5bc9
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,127 @@
+// Input as real Input System device state, so a remote finger takes the whole path a real one does: the EventSystem and
+// its buttons, the game's own touch layer, a HUD's hit test. Lifted from one game's remote-play server (the owner's), with the game-specific parts left to FunpixelProbe.Target and .Command.
+#if FUNPIXEL_INPUT_SYSTEM
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.InputSystem;
+using UnityEngine.InputSystem.LowLevel;
+using TouchPhase = UnityEngine.InputSystem.TouchPhase;
+
+namespace Funpixel.Probe
+{
+    internal sealed class Inject
+    {
+        int nextTouch = 1;
+        readonly HashSet<Key> keys = new HashSet<Key>();
+        GamepadState padState;
+        Gamepad pad;
+        bool mouseDown;
+
+        public int NewTouchId() => nextTouch++;
+
+        public void Touch(int id, TouchPhase phase, Vector2 px)
+        {
+            var ts = Touchscreen.current ?? InputSystem.AddDevice<Touchscreen>("FunpixelTouch");
+            // Touch id 0 means "no touch" to the Input System: remote fingers count from 1000.
+            InputSystem.QueueStateEvent(ts, new TouchState { touchId = 1000 + id, phase = phase, position = px, pressure = 1, radius = new Vector2(20, 20) });
+        }
+
+        public void Mouse(Vector2 px, bool down)
+        {
+            var m = UnityEngine.InputSystem.Mouse.current ?? InputSystem.AddDevice<UnityEngine.InputSystem.Mouse>("FunpixelMouse");
+            var st = new MouseState { position = px };
+            if (down) st = st.WithButton(MouseButton.Left, true);
+            mouseDown = down;
+            InputSystem.QueueStateEvent(m, st);
+        }
+
+        public bool Key(string name, bool down)
+        {
+            var k = KeyOf(name);
+            if (k == UnityEngine.InputSystem.Key.None) return false;
+            var kb = Keyboard.current ?? InputSystem.AddDevice<Keyboard>("FunpixelKeyboard");
+            if (down) keys.Add(k); else keys.Remove(k);
+            var arr = new Key[keys.Count];
+            keys.CopyTo(arr);
+            InputSystem.QueueStateEvent(kb, new KeyboardState(arr));
+            return true;
+        }
+
+        /// <summary>A key by Unity's name (Space, LeftArrow, A) or the web's code (Space, ArrowLeft, KeyA, Digit1, ShiftLeft).</summary>
+        public static Key KeyOf(string name)
+        {
+            if (string.IsNullOrEmpty(name)) return UnityEngine.InputSystem.Key.None;
+            string n = name.Trim();
+            switch (n)
+            {
+                case "ArrowLeft": return UnityEngine.InputSystem.Key.LeftArrow;
+                case "ArrowRight": return UnityEngine.InputSystem.Key.RightArrow;
+                case "ArrowUp": return UnityEngine.InputSystem.Key.UpArrow;
+                case "ArrowDown": return UnityEngine.InputSystem.Key.DownArrow;
+                case "ShiftLeft": return UnityEngine.InputSystem.Key.LeftShift;
+                case "ShiftRight": return UnityEngine.InputSystem.Key.RightShift;
+                case "ControlLeft": return UnityEngine.InputSystem.Key.LeftCtrl;
+                case "ControlRight": return UnityEngine.InputSystem.Key.RightCtrl;
+                case "AltLeft": return UnityEngine.InputSystem.Key.LeftAlt;
+                case "AltRight": return UnityEngine.InputSystem.Key.RightAlt;
+                case "MetaLeft": return UnityEngine.InputSystem.Key.LeftMeta;
+                case "MetaRight": return UnityEngine.InputSystem.Key.RightMeta;
+                case " ": return UnityEngine.InputSystem.Key.Space;
+            }
+            if (n.Length == 4 && n.StartsWith("Key", StringComparison.Ordinal)) n = n.Substring(3);
+            if (n.Length == 1 && char.IsDigit(n[0])) n = "Digit" + n;
+            return Enum.TryParse(n, true, out Key k) ? k : UnityEngine.InputSystem.Key.None;
+        }
+
+        public static GamepadButton? ButtonOf(string name)
+        {
+            switch ((name ?? "").Trim().ToLowerInvariant())
+            {
+                case "a": case "south": case "cross": return GamepadButton.South;
+                case "b": case "east": case "circle": return GamepadButton.East;
+                case "x": case "west": case "square": return GamepadButton.West;
+                case "y": case "north": case "triangle": return GamepadButton.North;
+                case "start": case "menu": case "options": return GamepadButton.Start;
+                case "select": case "back": case "view": return GamepadButton.Select;
+                case "lb": case "l1": case "leftshoulder": return GamepadButton.LeftShoulder;
+                case "rb": case "r1": case "rightshoulder": return GamepadButton.RightShoulder;
+                case "lt": case "l2": case "lefttrigger": return GamepadButton.LeftTrigger;
+                case "rt": case "r2": case "righttrigger": return GamepadButton.RightTrigger;
+                case "ls": case "l3": case "leftstick": return GamepadButton.LeftStick;
+                case "rs": case "r3": case "rightstick": return GamepadButton.RightStick;
+                case "up": case "dpadup": return GamepadButton.DpadUp;
+                case "down": case "dpaddown": return GamepadButton.DpadDown;
+                case "left": case "dpadleft": return GamepadButton.DpadLeft;
+                case "right": case "dpadright": return GamepadButton.DpadRight;
+                default: return null;
+            }
+        }
+
+        Gamepad Pad() => pad != null && pad.added ? pad : (pad = InputSystem.AddDevice<Gamepad>("FunpixelPad"));
+
+        public void PadButton(GamepadButton b, bool down)
+        {
+            padState = padState.WithButton(b, down);
+            InputSystem.QueueStateEvent(Pad(), padState);
+        }
+
+        public void PadStick(Vector2 left, Vector2? right = null)
+        {
+            padState.leftStick = left;
+            if (right.HasValue) padState.rightStick = right.Value;
+            InputSystem.QueueStateEvent(Pad(), padState);
+        }
+
+        /// <summary>Every remote finger, key, mouse button and pad input up (a client that lost track).</summary>
+        public void ReleaseAll()
+        {
+            if (Touchscreen.current != null) for (int id = 1; id < nextTouch + 8; id++) Touch(id, TouchPhase.Canceled, Vector2.zero);
+            keys.Clear();
+            if (Keyboard.current != null) InputSystem.QueueStateEvent(Keyboard.current, new KeyboardState());
+            if (mouseDown && UnityEngine.InputSystem.Mouse.current != null) Mouse(UnityEngine.InputSystem.Mouse.current.position.ReadValue(), false);
+            if (pad != null && pad.added) { padState = default; InputSystem.QueueStateEvent(pad, padState); }
+        }
+    }
+}
+#endif

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

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

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

@@ -0,0 +1,246 @@
+// A small JSON reader and writer, engine-free (the bridge's wire and the probe's report). One JSON object per line
+// on the wire, so the writer never emits a raw newline. Numbers read as double; objects as Dictionary<string, object>
+// (ordinal keys), arrays as List<object>.
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+
+namespace Funpixel.Probe
+{
+    public static class Json
+    {
+        // ── writing ──
+
+        public static string Write(object v)
+        {
+            var sb = new StringBuilder(256);
+            Write(sb, v);
+            return sb.ToString();
+        }
+
+        public static void Write(StringBuilder sb, object v)
+        {
+            switch (v)
+            {
+                case null: sb.Append("null"); break;
+                case string s: Str(sb, s); break;
+                case bool b: sb.Append(b ? "true" : "false"); break;
+                case double x: Num(sb, x); break;
+                case float f: Num(sb, f); break;
+                case int i: sb.Append(i.ToString(CultureInfo.InvariantCulture)); break;
+                case long l: sb.Append(l.ToString(CultureInfo.InvariantCulture)); break;
+                case uint u: sb.Append(u.ToString(CultureInfo.InvariantCulture)); break;
+                case ulong ul: sb.Append(ul.ToString(CultureInfo.InvariantCulture)); break;
+                case short sh: sb.Append(sh.ToString(CultureInfo.InvariantCulture)); break;
+                case byte by: sb.Append(by.ToString(CultureInfo.InvariantCulture)); break;
+                case Enum e: Str(sb, e.ToString()); break;
+                case IDictionary<string, object> d:
+                {
+                    sb.Append('{');
+                    bool first = true;
+                    foreach (var kv in d) { if (!first) sb.Append(','); first = false; Str(sb, kv.Key); sb.Append(':'); Write(sb, kv.Value); }
+                    sb.Append('}');
+                    break;
+                }
+                case IDictionary d2:
+                {
+                    sb.Append('{');
+                    bool first = true;
+                    foreach (DictionaryEntry kv in d2) { if (!first) sb.Append(','); first = false; Str(sb, Convert.ToString(kv.Key, CultureInfo.InvariantCulture)); sb.Append(':'); Write(sb, kv.Value); }
+                    sb.Append('}');
+                    break;
+                }
+                case IEnumerable list:
+                {
+                    sb.Append('[');
+                    bool first = true;
+                    foreach (var x in list) { if (!first) sb.Append(','); first = false; Write(sb, x); }
+                    sb.Append(']');
+                    break;
+                }
+                default: Str(sb, Convert.ToString(v, CultureInfo.InvariantCulture)); break;
+            }
+        }
+
+        static void Num(StringBuilder sb, double x)
+        {
+            if (double.IsNaN(x) || double.IsInfinity(x)) { sb.Append("null"); return; }
+            if (x == Math.Floor(x) && Math.Abs(x) < 1e15) sb.Append(((long)x).ToString(CultureInfo.InvariantCulture));
+            else sb.Append(x.ToString("R", CultureInfo.InvariantCulture));
+        }
+
+        public static void Str(StringBuilder sb, string s)
+        {
+            sb.Append('"');
+            foreach (char c in s)
+            {
+                switch (c)
+                {
+                    case '"': sb.Append("\\\""); break;
+                    case '\\': sb.Append("\\\\"); break;
+                    case '\n': sb.Append("\\n"); break;
+                    case '\r': sb.Append("\\r"); break;
+                    case '\t': sb.Append("\\t"); break;
+                    case '\b': sb.Append("\\b"); break;
+                    case '\f': sb.Append("\\f"); break;
+                    default:
+                        if (c < 0x20 || c == (char)0x2028 || c == (char)0x2029) sb.Append("\\u").Append(((int)c).ToString("x4"));
+                        else sb.Append(c);
+                        break;
+                }
+            }
+            sb.Append('"');
+        }
+
+        // ── reading ──
+
+        public sealed class ParseError : Exception { public ParseError(string m) : base(m) { } }
+
+        public static object Parse(string text)
+        {
+            if (text == null) throw new ParseError("no text");
+            int i = 0;
+            var v = Value(text, ref i);
+            Ws(text, ref i);
+            if (i != text.Length) throw new ParseError($"unexpected '{text[i]}' at {i}");
+            return v;
+        }
+
+        static void Ws(string s, ref int i) { while (i < s.Length && (s[i] == ' ' || s[i] == '\t' || s[i] == '\n' || s[i] == '\r')) i++; }
+
+        static object Value(string s, ref int i)
+        {
+            Ws(s, ref i);
+            if (i >= s.Length) throw new ParseError("unexpected end");
+            char c = s[i];
+            if (c == '{') return Obj(s, ref i);
+            if (c == '[') return Arr(s, ref i);
+            if (c == '"') return Text(s, ref i);
+            if (c == 't' && Lit(s, ref i, "true")) return true;
+            if (c == 'f' && Lit(s, ref i, "false")) return false;
+            if (c == 'n' && Lit(s, ref i, "null")) return null;
+            if (c == '-' || (c >= '0' && c <= '9')) return Number(s, ref i);
+            throw new ParseError($"unexpected '{c}' at {i}");
+        }
+
+        static bool Lit(string s, ref int i, string word)
+        {
+            if (string.CompareOrdinal(s, i, word, 0, word.Length) != 0) throw new ParseError($"bad literal at {i}");
+            i += word.Length;
+            return true;
+        }
+
+        static Dictionary<string, object> Obj(string s, ref int i)
+        {
+            var o = new Dictionary<string, object>(StringComparer.Ordinal);
+            i++;
+            Ws(s, ref i);
+            if (i < s.Length && s[i] == '}') { i++; return o; }
+            while (true)
+            {
+                Ws(s, ref i);
+                if (i >= s.Length || s[i] != '"') throw new ParseError($"expected a key at {i}");
+                var k = Text(s, ref i);
+                Ws(s, ref i);
+                if (i >= s.Length || s[i] != ':') throw new ParseError($"expected ':' at {i}");
+                i++;
+                o[k] = Value(s, ref i);
+                Ws(s, ref i);
+                if (i < s.Length && s[i] == ',') { i++; continue; }
+                if (i < s.Length && s[i] == '}') { i++; return o; }
+                throw new ParseError($"expected ',' or '}}' at {i}");
+            }
+        }
+
+        static List<object> Arr(string s, ref int i)
+        {
+            var a = new List<object>();
+            i++;
+            Ws(s, ref i);
+            if (i < s.Length && s[i] == ']') { i++; return a; }
+            while (true)
+            {
+                a.Add(Value(s, ref i));
+                Ws(s, ref i);
+                if (i < s.Length && s[i] == ',') { i++; continue; }
+                if (i < s.Length && s[i] == ']') { i++; return a; }
+                throw new ParseError($"expected ',' or ']' at {i}");
+            }
+        }
+
+        static string Text(string s, ref int i)
+        {
+            var sb = new StringBuilder();
+            i++;
+            while (i < s.Length)
+            {
+                char c = s[i++];
+                if (c == '"') return sb.ToString();
+                if (c != '\\') { sb.Append(c); continue; }
+                if (i >= s.Length) break;
+                char e = s[i++];
+                switch (e)
+                {
+                    case '"': sb.Append('"'); break;
+                    case '\\': sb.Append('\\'); break;
+                    case '/': sb.Append('/'); break;
+                    case 'b': sb.Append('\b'); break;
+                    case 'f': sb.Append('\f'); break;
+                    case 'n': sb.Append('\n'); break;
+                    case 'r': sb.Append('\r'); break;
+                    case 't': sb.Append('\t'); break;
+                    case 'u':
+                        if (i + 4 > s.Length) throw new ParseError("bad \\u escape");
+                        sb.Append((char)int.Parse(s.Substring(i, 4), NumberStyles.HexNumber, CultureInfo.InvariantCulture));
+                        i += 4;
+                        break;
+                    default: throw new ParseError($"bad escape \\{e}");
+                }
+            }
+            throw new ParseError("unterminated string");
+        }
+
+        static double Number(string s, ref int i)
+        {
+            int start = i;
+            if (s[i] == '-') i++;
+            while (i < s.Length && ((s[i] >= '0' && s[i] <= '9') || s[i] == '.' || s[i] == 'e' || s[i] == 'E' || s[i] == '+' || s[i] == '-')) i++;
+            if (!double.TryParse(s.Substring(start, i - start), NumberStyles.Float, CultureInfo.InvariantCulture, out var d)) throw new ParseError($"bad number at {start}");
+            return d;
+        }
+
+        // ── reading a request's fields ──
+
+        public static string S(IDictionary<string, object> a, string k) => a != null && a.TryGetValue(k, out var v) && v != null ? Convert.ToString(v, CultureInfo.InvariantCulture) : null;
+
+        public static double D(IDictionary<string, object> a, string k, double fallback = 0)
+        {
+            if (a == null || !a.TryGetValue(k, out var v) || v == null) return fallback;
+            if (v is double x) return x;
+            if (v is bool b) return b ? 1 : 0;
+            return double.TryParse(Convert.ToString(v, CultureInfo.InvariantCulture), NumberStyles.Float, CultureInfo.InvariantCulture, out var y) ? y : fallback;
+        }
+
+        public static int I(IDictionary<string, object> a, string k, int fallback) => (int)Math.Round(D(a, k, fallback));
+
+        public static bool B(IDictionary<string, object> a, string k)
+        {
+            if (a == null || !a.TryGetValue(k, out var v) || v == null) return false;
+            if (v is bool b) return b;
+            if (v is string s) return s == "1" || s == "true" || s == "on" || s == "yes";
+            return D(a, k) != 0;
+        }
+
+        public static bool Has(IDictionary<string, object> a, string k) => a != null && a.ContainsKey(k) && a[k] != null;
+
+        /// <summary>A [x, y] pair, or null when the field is absent or not a pair of numbers.</summary>
+        public static double[] Pair(IDictionary<string, object> a, string k)
+        {
+            if (a == null || !a.TryGetValue(k, out var v) || !(v is List<object> l) || l.Count < 2) return null;
+            try { return new[] { Convert.ToDouble(l[0], CultureInfo.InvariantCulture), Convert.ToDouble(l[1], CultureInfo.InvariantCulture) }; }
+            catch (Exception) { return null; }
+        }
+    }
+}

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

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