com.amanotes.gdk 0.2.66 → 0.2.68

package/Runtime/Fps/AmaFPS.Utils.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f9be250eab01474da9eea488bef071e0
+timeCreated: 1716886847

package/Runtime/Fps/AmaFPS.cs

@@ -0,0 +1,197 @@
+using System;
+using System.Collections.Generic;
+using Amanotes.Core.Internal;
+using static Amanotes.Core.Internal.Logging;
+using UnityEngine;
+using UnityEngine.Events;
+
+namespace Amanotes.Core.Internal
+{
+    public partial class ConfigAsset
+    {
+        [SerializeField]
+        public FPSConfig fpsConfig;
+    }
+}
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK
+    {
+        public static readonly AmaFPS FPS = new AmaFPS();
+    }
+    
+    
+    [Serializable]
+    public class FPSConfig
+    {
+        [Tooltip("Enable this to always record FPS for the app session. This allows developers to get the current FPS and current average FPS at any time.")]
+        public bool enableRealtimeFPS = false;
+
+        [Tooltip("The number of frames over which FPS is calculated. The FPS will be averaged after every 'frameGroup' frames.")]
+        [Range(1, 60)] 
+        public int frameGroup = 20;
+        
+        [Header("Lagging Tolerance")]
+        [Tooltip("The size of the sliding window used to calculate the Simple Moving Average (SMA) of the FPS.")]
+        [Range(10, 100)] 
+        public int windowSize = 15;
+        
+        [Tooltip("The allowed deviation from the SMA to detect an FPS drop.")]
+        [Range(0f, 0.3f)] 
+        public float deviation = 0.1f;
+        
+        [Tooltip("Number of frames to skip after OnApplicationFocus to avoid false alarms.")]
+        [Range(0, 60)] 
+        public int skipFrameFocus = 10;
+
+        [Header("Callback")]
+        [Tooltip("This callback is invoked when an FPS drop is detected.")]
+        public UnityEvent onFrameDrop = new UnityEvent();
+    }
+
+    public partial class AmaFPS // public API
+    {
+        
+        public float CurrentFPS => _realtime?.lastFPS ?? 0;
+        public float AverageFPS => _realtime?.avgFPS ?? 0;
+        public float MinFPS => _realtime?.minFPS ?? 0;
+        public float MaxFPS => _realtime?.maxFPS ?? 0;
+        public Action<string, Dictionary<string, object>> LogEventHook;
+
+        private bool _isAppReady = false;
+        private int _playCount = 0;
+
+        public void TrackLaunchTime()
+        {
+            if (_isAppReady)
+            {
+                Log("TrackAppReady() being called multiple time!");
+                return;
+            }
+            _isAppReady = true;
+
+            var dict = new Dictionary<string, object>()
+            {
+                {"loading_time", Time.realtimeSinceStartup},
+                {"session", AmaGDK.User.Session},
+                {"device_name", SystemInfo.deviceModel},
+                {"device_os_version", SystemInfo.operatingSystem},
+
+                // Update
+                {"game_time", Time.time},
+            };
+
+            Utils.InjectDeviceInfo(dict);
+            Utils.InjectDeviceStatus(dict);
+
+            LogEvent("pm_launch_time", dict);
+        }
+        
+        public void StartRecordFPS(string context, Dictionary<string, object> userData = null)
+        {
+            _recorder ??= new FrameRecorder(_config ?? AmaGDK.Config.fpsConfig);
+            if (_recorder.isRecording)
+            {
+                LogWarning("Not yet support - Start multiple recorders at the same time! Please stop the previous session first!");
+                return;
+            }
+
+            _recorder.Start(context, userData);
+        }
+        
+        public Dictionary<string, object> StopRecordFPS(bool logEvent = true)
+        {
+            if (_recorder == null || !_recorder.isRecording)
+            {
+                LogWarning("No tracking session found!");
+                return null;
+            }
+
+            var data = _recorder.Stop();
+            if (logEvent) LogEvent("fps_measurement", data);
+            return data;
+        }
+
+        private void LogEvent(string eventName, Dictionary<string, object> parameters)
+        {
+            if (LogEventHook == null)
+            {
+                AmaGDK.Analytics.LogEvent(eventName, parameters);
+                return;
+            }
+            LogEventHook(eventName, parameters);
+        }
+    }
+
+    public partial class AmaFPS: IOnApplicationFocus, IOnApplicationPause, IOnFrameUpdate // Internal logic
+    {
+        private FrameRecorder _recorder;
+        private FrameRecorder _realtime;
+        private int _skipFrames = 0;
+        private FPSConfig _config;
+
+        internal AmaFPS()
+        {
+            AmaGDK.SetCallback_OnGDKInit(OnGDKInit);
+            AmaGDK.unityCallbacks.AddObserver(this);
+        }
+        
+        internal AmaFPS(FPSConfig config)
+        {
+            // Constructor for unit test
+            _config = config;
+            _realtime = new FrameRecorder(config);
+        }
+
+        private void OnGDKInit()
+        {
+            _config = AmaGDK.Config.fpsConfig;
+            _realtime ??= new FrameRecorder(_config);
+            
+            _realtime.bands.onFPSDrop -= OnFrameDrop;
+            _realtime.bands.onFPSDrop += OnFrameDrop;
+        }
+
+        private void OnFrameDrop()
+        {
+            if (_config.onFrameDrop.GetPersistentEventCount() > 0)
+            {
+                _config.onFrameDrop.Invoke();
+            }
+        }
+
+        public void OnFrameUpdate()
+        {
+            UpdateFrame(Time.unscaledDeltaTime);
+        }
+
+        internal void UpdateFrame(float unscaledDeltaTime)
+        {
+            if (unscaledDeltaTime <= 1 / 1200f) unscaledDeltaTime = 1 / 1200f; // prevent the case when unscaledDeltaTime == 0
+
+            if (_skipFrames > 0)
+            {
+                _skipFrames--;
+                return;
+            }
+            
+            if (_realtime != null && _config.enableRealtimeFPS) _realtime.UpdateFrame(unscaledDeltaTime);
+            
+            if (_recorder != null && _recorder.isRecording)
+            {
+                _recorder.UpdateFrame(unscaledDeltaTime);
+            }
+        }
+
+        public void OnApplicationFocus(bool hasFocus)
+        {
+            _skipFrames = _config?.skipFrameFocus ?? 0;
+        }
+
+        public void OnApplicationPause(bool pauseStatus)
+        {
+            _skipFrames = _config?.skipFrameFocus ?? 0;
+        }
+    }
+}

package/Runtime/Fps/AmaFPS.cs.meta

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

package/Runtime/Fps/AmaFPSVisualizer.cs

@@ -0,0 +1,246 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Profiling;
+using UnityEngine.UI;
+using static Amanotes.Core.Internal.Logging;
+
+namespace Amanotes.Core
+{
+
+    [RequireComponent(typeof(RectTransform))]
+    [RequireComponent(typeof(CanvasRenderer))]
+    public class AmaFPSVisualizer : Graphic
+    {
+        [Serializable]
+        private class FlashOnDrop
+        {
+            public bool enabled = true;
+            public Color flashColor = new Color(1, 0, 0, 0.5f);
+            [Range(1f, 10f)] public float flashingSpeed = 10f;
+
+            public Image flashImage;
+            private float _alpha = 0;
+
+            public void OnFrameDrop()
+            {
+                _alpha = flashColor.a;
+                flashImage.color = flashColor;
+            }
+            
+            public void Update()
+            {
+                float dAlpha = flashingSpeed * Time.deltaTime;
+                _alpha = Mathf.Max(0, _alpha - dAlpha);
+
+                Color c = flashColor;
+                c.a = _alpha;
+                flashImage.color = c;
+            }
+        }
+
+        [Serializable]
+        private class FPSTextUpdate
+        {
+            private static readonly Dictionary<int, string> intMap = new Dictionary<int, string>();
+            private static string GetString(float value)
+            {
+                Profiler.BeginSample("FPSTextUpdate.GetString");
+                int intValue = Mathf.RoundToInt(value * 10);
+                if (intMap.TryGetValue(intValue, out string result))
+                {
+                    Profiler.EndSample();
+                    return result;
+                }
+                
+                result = $"{(intValue/10f):F1}";
+                intMap.Add(intValue, result);
+                Profiler.EndSample();
+                return result;
+            }
+            
+            public bool enabled = true;
+            public GameObject parent = null;
+
+            public Text currentFPS;
+            private int frame;
+            
+            public void Update(float fps)
+            {
+                if (frame-- > 0) return;
+                currentFPS.text = GetString(fps);
+                frame = 60;
+            }
+        }
+
+        struct FPSVertex
+        {
+            public float fps;
+            public int colorIndex;
+            public Vector3 position;
+        }
+
+        [Serializable]
+        private class FPSGraph : FrameRecorder
+        {
+            const int RESOLUTION = 64;
+            public bool enabled = true;
+            public Graphic graphic = null;
+
+            public int minFPS = 15;
+            public int maxFPS = 60;
+            public int goodFPS = 55;
+            public int acceptableFPS = 45;
+            public int badFPS = 30;
+
+            public Color[] colors = new Color[]{
+                Color.red, // min -> bad
+                new Color(1f, 0.65f, 0f), // bad -> ok
+                Color.yellow, // ok --> good
+                Color.green, // very good
+            };
+
+            private readonly float[] fpsHistory = new float[RESOLUTION];
+            private int vCount = 0;
+
+            public void Clear()
+            {
+                vCount = 0;
+            }
+
+            protected override void UpdateGroupFrame(){
+                var hIndex = vCount % RESOLUTION;
+                fpsHistory[hIndex] = lastFPS;
+                vCount++;
+            }
+
+            public void PopulateMesh(VertexHelper vh)
+            {
+                var rect = ((RectTransform)graphic.transform).rect;
+                var barW = rect.width / (RESOLUTION-1);
+                var barH = rect.height;
+
+                var barX = vCount < RESOLUTION ? (RESOLUTION - vCount) * barW : 0;
+                var stIndex = vCount <= RESOLUTION ? 0 : (vCount % RESOLUTION);
+                var nVertex = vCount <= RESOLUTION ? vCount : RESOLUTION;
+
+                for (var i = 0; i < nVertex; i++)
+                {
+                    var idx = (i + stIndex) % RESOLUTION;
+                    var fps = fpsHistory[idx];
+                    var h = fps <= minFPS ? 0 :
+                                fps >= maxFPS ? 1 : (fps - minFPS) / (maxFPS - minFPS);
+
+                    var v0 = new Vector3(barX, 0, 0);
+                    var v1 = new Vector3(barX, h * barH, 0);
+                    var c1 = colors[
+                                fps <= badFPS ? 0 :
+                                fps <= acceptableFPS ? 1 :
+                                fps <= goodFPS ? 2 : 3
+                            ];
+                    var c0 = c1;
+                    c0.a = 0;
+
+                    // Add 2 vertices
+                    vh.AddVert(v0, c0, Vector2.zero);
+                    vh.AddVert(v1, c1, Vector2.zero);
+
+                    if (i > 0)
+                    {
+                        var vIndex = vh.currentVertCount - 2;
+                        vh.AddTriangle(vIndex - 2, vIndex - 1, vIndex + 1);
+                        vh.AddTriangle(vIndex - 2, vIndex + 1, vIndex);
+                    }
+
+                    barX += barW;
+                }
+
+                AddHorzLine(vh, rect.width, barH * ((goodFPS-minFPS) / (float)(maxFPS-minFPS)), colors[2], 2f);
+                AddHorzLine(vh, rect.width, barH * ((acceptableFPS-minFPS) / (float)(maxFPS-minFPS)), colors[1], 2f);
+                AddHorzLine(vh, rect.width, barH * ((badFPS-minFPS) / (float)(maxFPS-minFPS)), colors[0], 2f);
+            }
+
+            void AddHorzLine(VertexHelper vh, float w, float h, Color color, float thickness = 1f)
+            {
+                var v0 = new Vector3(0, h, 0);
+                var v1 = new Vector3(w, h, 0);
+                var v2 = new Vector3(w, h+thickness, 0);
+                var v3 = new Vector3(0, h+thickness, 0);
+                
+                var vIndex = vh.currentVertCount;
+                
+                vh.AddVert(v0, color, new Vector2(0, 0));
+                vh.AddVert(v1, color, new Vector2(0, 0));
+                vh.AddVert(v2, color, new Vector2(0, 0));
+                vh.AddVert(v3, color, new Vector2(0, 0));
+
+                vh.AddTriangle(vIndex, vIndex+1, vIndex+2);
+                vh.AddTriangle(vIndex+2, vIndex+3, vIndex);
+            }
+
+            public FPSGraph(FPSConfig config) : base(config)
+            {
+            }
+        }
+
+        [SerializeField] private FlashOnDrop flashOnDropFrame = new FlashOnDrop();
+        [SerializeField] private FPSTextUpdate textUpdate = new FPSTextUpdate();
+        
+        private FPSGraph graph;
+        
+        protected override void Awake()
+        {
+            flashOnDropFrame.flashImage.enabled = flashOnDropFrame.enabled;
+            textUpdate.parent.SetActive(textUpdate.enabled);
+            
+            graph = new FPSGraph(AmaGDK.Config.fpsConfig)
+            {
+                graphic = GetComponent<Graphic>()
+            };
+            
+            Application.targetFrameRate = Screen.currentResolution.refreshRate;
+            Log($"Target FrameRate: {Application.targetFrameRate}");
+        }
+
+        protected override void Start()
+        {
+            var rect = Screen.safeArea;
+            var trans = transform as RectTransform;
+            var transRect = trans.rect;
+            trans.anchoredPosition = new Vector2(rect.x / rect.width * transRect.width, -rect.y / rect.height * transRect.height);
+        }
+
+        public void OnFrameDrop()
+        {
+            flashOnDropFrame.OnFrameDrop();
+        }
+
+        private void Update()
+        {
+            if (!Application.isPlaying) return;
+            Profiler.BeginSample("AmaFPSVisualiser.Update()");
+            {
+                if (flashOnDropFrame.enabled) flashOnDropFrame.Update();
+                if (textUpdate.enabled) textUpdate.Update(1f/Time.unscaledDeltaTime);
+                if (graph != null && graph.enabled)
+                {
+                    graph.UpdateFrame(Time.unscaledDeltaTime);
+                    Profiler.BeginSample("SetVerticesDirty()");
+                    {
+                        SetVerticesDirty();
+                    }
+                    Profiler.EndSample();
+                }    
+            }
+            Profiler.EndSample();
+        }
+
+        protected override void OnPopulateMesh(VertexHelper vh)
+        {
+            vh.Clear();
+
+            if (graph == null || !graph.enabled) return;
+            graph.PopulateMesh(vh);
+        }
+    }
+}

package/Runtime/Fps/AmaFPSVisualizer.cs.meta

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

package/Runtime/Fps/BollingerBands.cs

@@ -0,0 +1,99 @@
+using System;
+using Amanotes.Core.Internal;
+
+namespace Amanotes.Core
+{
+    internal class BollingerBands
+    {
+        internal event Action onFPSDrop;
+        internal int currentDropCount { get; private set; }
+        internal int totalDrop { get; private set; }
+        internal int isoDrop { get; private set; }
+        
+        private readonly float[] buffer;
+        private readonly float tolerance;
+        private int bIndex;
+        private float sum;
+
+        internal BollingerBands(int window = 20, float deviation = 0.1f)
+        { // ~10%
+            buffer = new float[window];
+            tolerance = 1f - deviation;
+        }
+
+        internal void Reset(float v)
+        {
+            for (var i = 0; i < buffer.Length; i++)
+            {
+                buffer[i] = v;
+            }
+
+            bIndex = 0;
+            currentDropCount = 0;
+            totalDrop = 0;
+            isoDrop = 0;
+            _last = v;
+            sum = v * buffer.Length;
+        }
+
+        internal float last => _last;
+        internal float avg => sum / buffer.Length;
+        internal float min => (_min == -1) ? CalculateMinMax()._min : _min;
+        internal float max => (_max == -1) ? CalculateMinMax()._max : _max;
+
+        internal bool Add(float v)
+        {
+            // update cached min / max
+            if (_min != -1 && v < _min) _min = v;
+            if (_max != -1 && v > _max) _max = v;
+
+            float v0 = buffer[bIndex];
+            buffer[bIndex] = v;
+            sum += v - v0;
+            bIndex = (bIndex + 1) % buffer.Length;
+            _last = v;
+
+            // clear cached min / max
+            if (v0 == _min) _min = -1;
+            if (v0 == _max) _max = -1;
+
+            float sma = sum / buffer.Length;
+            bool isDrop = v < sma * tolerance;
+
+            if (!isDrop)
+            {
+                currentDropCount = 0;
+                return false;
+            }
+
+            totalDrop++;
+            currentDropCount++;
+
+            if (currentDropCount == 1)
+            {
+                isoDrop++;
+                GDKUtils.SafeInvoke(onFPSDrop);
+            }
+            return true;
+        }
+
+        private float _min;
+        private float _max;
+        private float _last;
+
+        private BollingerBands CalculateMinMax()
+        {
+            _min = buffer[0];
+            _max = _min;
+
+            for (var i = 1; i < buffer.Length; i++)
+            {
+                float v = buffer[i];
+                if (v < _min) _min = v;
+                if (v > _max) _max = v;
+            }
+
+            return this;
+        }
+    }
+}

package/Runtime/Fps/BollingerBands.cs.meta

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