com.amanotes.gdk 0.2.70 → 0.2.72

package/Runtime/Core/GDKDebug.cs

@@ -0,0 +1,97 @@
+using Amanotes.Core.Internal;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+namespace Amanotes.Core
+{
+    public enum LogLevel
+    {
+        None,
+        Error,
+        Warning,
+        Verbose
+    }
+
+    internal struct NoStackTrace : IDisposable
+    {
+        internal LogType logType;
+        internal StackTraceLogType stackTraceType;
+
+        internal NoStackTrace(LogType logType)
+        {
+            this.logType = logType;
+            stackTraceType = Application.GetStackTraceLogType(logType);
+            Application.SetStackTraceLogType(logType, StackTraceLogType.None);
+        }
+        
+        public void Dispose()
+        {
+            Application.SetStackTraceLogType(logType, stackTraceType);
+        }
+
+        public static NoStackTrace Error => new NoStackTrace(LogType.Error);
+        public static NoStackTrace Warning => new NoStackTrace(LogType.Warning);
+        public static NoStackTrace Log => new NoStackTrace(LogType.Log);
+    }
+    
+    public class GDKDebug
+    {
+        public static LogLevel logLevel;
+        public static Action<string> logNonfatalErrorHook = null;
+        private static readonly HashSet<string> nonFatalDict = new HashSet<string>();
+        public static readonly HashSet<string> logWarningDict = new HashSet<string>();
+        
+        public static void LogWarningOnce(string message, string key = null)
+        {
+            if (logLevel < LogLevel.Warning) return;
+            if (string.IsNullOrEmpty(key)) key = message;
+            if (!logWarningDict.Add(key)) return;
+            
+            using (NoStackTrace.Warning)
+            {
+                Debug.LogWarning($"AmaGDK {message}"); 
+            }
+        }
+        public static void LogWarning(string message)
+        {
+            if (logLevel < LogLevel.Warning) return;
+            using (NoStackTrace.Warning)
+            {
+                Debug.LogWarning($"AmaGDK {message}"); 
+            }
+        }
+        public static void LogError(string message)
+        {
+            if (logLevel < LogLevel.Error) return;
+            using (NoStackTrace.Error)
+            {
+                Debug.LogError($"AmaGDK {message}");    
+            }
+            
+            if (logNonfatalErrorHook == null) return;
+            GDKUtils.DoOnMainThread(() =>
+            {
+                if (!nonFatalDict.Add(message)) return; // LogOnce
+                logNonfatalErrorHook(message);
+            });
+        }
+        
+        public static void Log(string message)
+        {
+            if (logLevel < LogLevel.Verbose) return;
+            using (NoStackTrace.Log)
+            {
+                Debug.Log($"AmaGDK {message}");   
+            }
+        }
+        
+        public static void ForceLog(string message)
+        {
+            using (NoStackTrace.Log)
+            {
+                Debug.Log($"AmaGDK {message}");   
+            }
+        }
+    }
+}
+

package/Runtime/Core/GDKDebug.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 952f1023aed84e35b18d0be8ae20dda9
+timeCreated: 1724669802

package/Runtime/Core/GDKPool.cs

@@ -3,6 +3,7 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Text;
 
+using static Amanotes.Core.GDKDebug;
 namespace Amanotes.Core.Internal
 {
     public interface IPoolItem

package/Runtime/Core/GDKRoutine.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections;
 using UnityEngine;
+using static Amanotes.Core.GDKDebug;
+
 namespace Amanotes.Core.Internal
 {
     public class GDKRoutine
@@ -59,7 +61,7 @@ namespace Amanotes.Core.Internal
                 } catch (Exception ex)
                 {
                     status |= RoutineStatus.Stopped;
-                    if (exceptionHandler == null) Logging.LogError($"Exception caught in coroutine: {ex}");
+                    if (exceptionHandler == null) LogError($"Exception caught in coroutine: {ex}");
                     exceptionHandler?.Invoke(ex);
                     yield break; // Stop executing the coroutine
                 }

package/Runtime/Core/GDKSemVer.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
 using UnityEngine.Profiling;
-using static Amanotes.Core.Internal.Logging;
+using static Amanotes.Core.GDKDebug;
 
 namespace Amanotes.Core.Internal
 {

package/Runtime/Core/GDKString.cs

@@ -0,0 +1,197 @@
+using System;
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    public static class GDKStringExtension
+    {
+        internal static void Log(GDKString gdkStr, LogType logType, UnityEngine.Object context, Action<string, UnityEngine.Object> logFunc)
+        {
+            StackTraceLogType type = Application.GetStackTraceLogType(logType);
+            Application.SetStackTraceLogType(logType, StackTraceLogType.None);
+            {
+                logFunc(gdkStr.ToString(), context);
+            }
+            Application.SetStackTraceLogType(logType, type);
+            gdkStr.Clear();
+        }
+
+        public static void Log(this GDKString gdkStr, UnityEngine.Object context = null)
+        {
+            Log(gdkStr, LogType.Log, context, Debug.Log);
+        }
+
+        public static void LogWarning(this GDKString gdkStr, UnityEngine.Object context = null)
+        {
+            Log(gdkStr, LogType.Warning, context, Debug.LogWarning);
+        }
+        
+        public static void LogError(this GDKString gdkStr, UnityEngine.Object context = null)
+        {
+            Log(gdkStr, LogType.Error, context, Debug.LogError);
+        }
+        
+        private static readonly char[] DigitChars = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
+        internal static unsafe int Write(string s, int stIndex, ulong value, bool writePrefix = false, char prefix = '-')
+        {
+            fixed (char* ptr = s)
+            {
+                var idx = 0;
+                if (writePrefix)
+                {
+                    ptr[stIndex] = prefix;
+                    idx++;
+                }
+                
+                if (value <= 9)
+                {
+                    ptr[stIndex + idx] = DigitChars[value];
+                    idx++;
+                    return idx;
+                }
+
+                var len = (int)Math.Ceiling(Math.Log10(value));
+                int endIdx = stIndex + len - 1 + idx;
+                do
+                {
+                    ptr[endIdx] = (char)('0' + value % 10);
+                    endIdx--;
+                    value /= 10;
+                } while (value > 0);
+
+                idx += len;
+                return idx;
+            }
+        }
+
+        internal static int WriteULong(this string s, int stIndex, ulong value)
+        {
+            return Write(s, stIndex, value);
+        }
+        
+        internal static int WriteLong(this string s, int stIndex, long value)
+        {
+            return Write(s, stIndex, (ulong)(value < 0 ? -value : value), value < 0, '-');
+        }
+        
+        internal static int WriteDouble(this string s, int stIndex, double value, int decimalPlaces = 4)
+        {
+            var integerPart = (ulong)value;
+            int counter = Write(s, stIndex, integerPart, value < 0);
+            if (decimalPlaces <= 0) return counter;
+            
+            double fractionalPart = value - integerPart;
+            for (var i = 0; i < decimalPlaces; i++)
+            {
+                fractionalPart *= 10;
+            }
+            
+            var fractionalInt = (ulong)(fractionalPart + 0.5);
+            counter += Write(s, stIndex + counter, fractionalInt, true, '.');
+            return counter;
+        }
+    }
+    
+    public unsafe class GDKString
+    {
+        private readonly int _capacity;
+        private readonly string _str;
+        private int _length;
+        
+        public GDKString(int capacity)
+        {
+            _capacity = capacity;
+            _str = new string('\0', capacity);
+            _length = 0;
+        }
+
+        public int Length => _length;
+
+        private GDKString SetLength(int value)
+        {
+            if (value < 0 || value > _capacity)
+            {
+                throw new ArgumentOutOfRangeException(nameof(value));
+            }
+            
+            _length = value;
+            fixed (char* ptr = _str)
+            {
+                ptr[value] = '\0';
+                *(int*)((IntPtr)ptr - sizeof(int)) = _length;
+            }
+
+            return this;
+        }
+
+        public GDKString Append(string value)
+        {
+            return string.IsNullOrEmpty(value) ? this : WriteAt(_length, value);
+        }
+        
+        public GDKString WriteAt(int stIdx, string value)
+        {
+            if (string.IsNullOrEmpty(value)) return this;
+            
+            int vLength = value.Length;
+            if (stIdx + vLength >= _capacity)
+            {
+                throw new InvalidOperationException("Buffer overflow.");
+            }
+            
+            // Calculate the number of bytes to copy (2 bytes per char)
+            fixed (char* srcPtr = value)
+            fixed (char* destPtr = _str)
+            {
+                // Use memcpy equivalent with pointers
+                char* destPos = destPtr + _length;
+                for (var i = 0; i < vLength; i++)
+                {
+                    *(destPos + i) = *(srcPtr + i);
+                }
+            }
+
+            if (stIdx + vLength > _length) SetLength(_length + vLength);
+            return this;
+        }
+        
+        public GDKString Append(int value)
+        {
+            int vLength = _str.WriteLong(Length, value);
+            return SetLength(_length + vLength);
+        }
+
+        public GDKString Append(uint value)
+        {
+            int vLength = _str.WriteULong(Length, value);
+            return SetLength(_length + vLength);
+        }
+
+        private const string TRUE = "True";
+        private const string FALSE = "False";
+        public GDKString Append(bool value)
+        {
+            Append(value ? TRUE : FALSE);
+            return this;
+        }
+
+        public GDKString Append(float value)
+        {
+            int vLength = _str.WriteDouble(Length, value);
+            return SetLength(_length + vLength);
+        }
+
+        public GDKString Append(double value)
+        {
+            int vLength = _str.WriteDouble(Length, value);
+            return SetLength(_length + vLength);
+        }
+        
+        public GDKString Clear()
+        {
+            return SetLength(0);
+        }
+
+        public override string ToString() => _str;
+    }
+}

package/Runtime/Core/GDKString.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1b832c4b2bab4b7d8f05c2d315eb6f85
+timeCreated: 1724065190

package/Runtime/EmbedRemoteConfigAsset.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using UnityEngine;
+using static Amanotes.Core.GDKDebug;
 
 namespace Amanotes.Core.Internal
 {
@@ -30,7 +31,7 @@ namespace Amanotes.Core.Internal
         {
             var config = configs?.FirstOrDefault(a => a.id == id);
             if (config == null)
-                Logging.LogWarningOnce($"Not found embedded config <{id}>");
+                LogWarningOnce($"Not found embedded config <{id}>");
             return config;
         }
 

package/Runtime/Fps/AmaFPS.Utils.cs

@@ -1,5 +1,5 @@
 using System.Collections.Generic;
-using static Amanotes.Core.Internal.Logging;
+using static Amanotes.Core.GDKDebug;
 using UnityEngine;
 namespace Amanotes.Core
 {
@@ -27,7 +27,7 @@ namespace Amanotes.Core
                 var resolution = Screen.currentResolution;
                 dictionary.Add("system_memory_size", SystemInfo.systemMemorySize);
                 dictionary.Add("graphics_memory_size", SystemInfo.graphicsMemorySize);
-                dictionary.Add("graphics_device_type", SystemInfo.graphicsDeviceType);
+                dictionary.Add("graphics_device_type", SystemInfo.graphicsDeviceType.ToString());
                 dictionary.Add("graphics_shader_level", SystemInfo.graphicsShaderLevel);
                 dictionary.Add("processor_count", SystemInfo.processorCount);
                 dictionary.Add("processor_frequency", SystemInfo.processorFrequency);

package/Runtime/Fps/AmaFPS.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 using Amanotes.Core.Internal;
-using static Amanotes.Core.Internal.Logging;
+using static Amanotes.Core.GDKDebug;
 using UnityEngine;
 using UnityEngine.Events;
 

package/Runtime/Fps/AmaFPSVisualizer.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.Profiling;
 using UnityEngine.UI;
-using static Amanotes.Core.Internal.Logging;
+using static Amanotes.Core.GDKDebug;
 
 namespace Amanotes.Core
 {

package/Runtime/Fps/FrameRecorder.cs

@@ -2,7 +2,7 @@
 using System;
 using System.Collections.Generic;
 using UnityEngine;
-using static Amanotes.Core.Internal.Logging;
+using static Amanotes.Core.GDKDebug;
 
 namespace Amanotes.Core
 {