com.beanbag.tiktokminigames 1.0.0

package/WebGL/FileSystem/TTFileSystemManagerWebGL.cs.meta

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

package/WebGL/FileSystem.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ee3589cfda00f4b83b30a2ea728aff3b
+timeCreated: 1678263355

package/WebGL/Input/Input.cs

@@ -0,0 +1,230 @@
+#if UNITY_WEBGL && STARK_UNITY_INPUT_OVERRIDE
+
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+/// <summary>
+/// Interface into the Input system. (Overridden by TTSDK)
+/// </summary>
+/// <remarks>
+/// 覆盖 Input，用于将 Input.GetTouch() 等方法重载至 TTSDK 中的实现。
+/// 因为编译器解析引用时，全局命名空间中的类优先级更高，Input.GetTouch() 等方法将优先选择当前类而非 UnityEngine.Input.
+/// * 通过 STARK_UNITY_INPUT_OVERRIDE 符号控制开关，默认关闭。关闭时与 UnityEngine.Input 无差异。
+/// * 不会重载以完全限定名形式（UnityEngine.Input）书写的调用，仅重载 Input.XXX。
+/// * 不会重载动态链接库（DLL）中对 UnityEngine.Input 的直接调用。
+/// </remarks>
+public static class Input
+{
+    static Input()
+    {
+        Debug.Log("Global Input overridden by TTSDK.");
+    }
+
+    #region Touch Override
+
+    private static BaseInputModule CurrentInputModule => EventSystem.current.currentInputModule;
+
+    private static bool Enabled => true;
+
+    #endregion
+
+    #region Touch
+
+    public static Touch GetTouch(int index)
+    {
+        if (!Enabled) return UnityEngine.Input.GetTouch(index);
+
+        return CurrentInputModule.input.GetTouch(index);
+    }
+
+    public static int touchCount
+    {
+        get { return Enabled ? CurrentInputModule.input.touchCount : UnityEngine.Input.touchCount; }
+    }
+
+    public static bool touchPressureSupported => UnityEngine.Input.touchPressureSupported;
+
+    public static bool stylusTouchSupported => UnityEngine.Input.stylusTouchSupported;
+
+    public static bool touchSupported
+    {
+        get { return Enabled ? CurrentInputModule.input.touchSupported : UnityEngine.Input.touchSupported; }
+    }
+
+    public static bool multiTouchEnabled => UnityEngine.Input.multiTouchEnabled;
+
+    public static Touch[] touches
+    {
+        get
+        {
+            if (!Enabled) return UnityEngine.Input.touches;
+
+            var touchCount = CurrentInputModule.input.touchCount;
+            var touches = new Touch[touchCount];
+            for (var index = 0; index < touchCount; ++index) touches[index] = CurrentInputModule.input.GetTouch(index);
+            return touches;
+        }
+    }
+
+    #endregion
+
+    #region Mouse
+
+    public static Vector3 mousePosition
+    {
+        get
+        {
+            if (!Enabled) return UnityEngine.Input.mousePosition;
+
+            return new Vector3(CurrentInputModule.input.mousePosition.x, CurrentInputModule.input.mousePosition.y,
+                0.0f);
+        }
+    }
+
+    public static Vector2 mouseScrollDelta
+    {
+        get { return Enabled ? CurrentInputModule.input.mouseScrollDelta : UnityEngine.Input.mouseScrollDelta; }
+    }
+
+    public static bool mousePresent => Enabled ? CurrentInputModule.input.mousePresent : UnityEngine.Input.mousePresent;
+
+    public static bool GetMouseButton(int button)
+    {
+        return Enabled ? CurrentInputModule.input.GetMouseButton(button) : UnityEngine.Input.GetMouseButton(button);
+    }
+
+    public static bool GetMouseButtonDown(int button)
+    {
+        return Enabled ? CurrentInputModule.input.GetMouseButtonDown(button) : UnityEngine.Input.GetMouseButton(button);
+    }
+
+    public static bool GetMouseButtonUp(int button)
+    {
+        return Enabled ? CurrentInputModule.input.GetMouseButtonUp(button) : UnityEngine.Input.GetMouseButtonUp(button);
+    }
+
+    #endregion
+
+    public static float GetAxis(string axisName)
+    {
+        return UnityEngine.Input.GetAxis(axisName);
+    }
+
+    public static float GetAxisRaw(string axisName)
+    {
+        return UnityEngine.Input.GetAxisRaw(axisName);
+    }
+
+    public static bool GetButton(string buttonName)
+    {
+        return UnityEngine.Input.GetButton(buttonName);
+    }
+
+    public static bool GetButtonDown(string buttonName)
+    {
+        return UnityEngine.Input.GetButtonDown(buttonName);
+    }
+
+    public static bool GetButtonUp(string buttonName)
+    {
+        return UnityEngine.Input.GetButtonUp(buttonName);
+    }
+
+    public static void ResetInputAxes()
+    {
+        UnityEngine.Input.ResetInputAxes();
+    }
+
+#if UNITY_STANDLONE_LINUX
+    public static bool IsJoystickPreconfigured(string joystickName)
+    {
+      return UnityEngine.Input.IsJoystickPreconfigured(joystickName);
+    }
+#endif
+
+    public static string[] GetJoystickNames()
+    {
+        return UnityEngine.Input.GetJoystickNames();
+    }
+
+    public static AccelerationEvent GetAccelerationEvent(int index)
+    {
+        return UnityEngine.Input.GetAccelerationEvent(index);
+    }
+
+    public static bool GetKey(KeyCode key) => UnityEngine.Input.GetKey(key);
+
+    public static bool GetKey(string name) => UnityEngine.Input.GetKey(name);
+
+    public static bool GetKeyUp(KeyCode key) => UnityEngine.Input.GetKeyUp(key);
+
+    public static bool GetKeyUp(string name) => UnityEngine.Input.GetKeyUp(name);
+
+    public static bool GetKeyDown(KeyCode key) => UnityEngine.Input.GetKeyDown(key);
+
+    public static bool GetKeyDown(string name) => UnityEngine.Input.GetKeyDown(name);
+
+    public static bool simulateMouseWithTouches
+    {
+        get => UnityEngine.Input.simulateMouseWithTouches;
+        set => UnityEngine.Input.simulateMouseWithTouches = value;
+    }
+
+    public static bool anyKey => UnityEngine.Input.anyKey;
+
+    public static bool anyKeyDown => UnityEngine.Input.anyKeyDown;
+
+    public static string inputString => UnityEngine.Input.inputString;
+
+    public static IMECompositionMode imeCompositionMode
+    {
+        get => UnityEngine.Input.imeCompositionMode;
+        set => UnityEngine.Input.imeCompositionMode = value;
+    }
+
+    public static string compositionString => UnityEngine.Input.compositionString;
+
+    public static bool imeIsSelected => UnityEngine.Input.imeIsSelected;
+
+    public static Vector2 compositionCursorPos
+    {
+        get => UnityEngine.Input.compositionCursorPos;
+        set => UnityEngine.Input.compositionCursorPos = value;
+    }
+
+    public static bool eatKeyPressOnTextFieldFocus
+    {
+        get => UnityEngine.Input.eatKeyPressOnTextFieldFocus;
+        set => UnityEngine.Input.eatKeyPressOnTextFieldFocus = value;
+    }
+
+    public static bool isGyroAvailable => UnityEngine.Input.isGyroAvailable;
+
+    public static DeviceOrientation deviceOrientation => UnityEngine.Input.deviceOrientation;
+
+    public static Vector3 acceleration => UnityEngine.Input.acceleration;
+
+    public static bool compensateSensors
+    {
+        get => UnityEngine.Input.compensateSensors;
+        set => UnityEngine.Input.compensateSensors = value;
+    }
+
+    public static int accelerationEventCount => UnityEngine.Input.accelerationEventCount;
+
+    public static bool backButtonLeavesApp
+    {
+        get => UnityEngine.Input.backButtonLeavesApp;
+        set => UnityEngine.Input.backButtonLeavesApp = value;
+    }
+
+    public static LocationService location => UnityEngine.Input.location;
+
+    public static Compass compass => UnityEngine.Input.compass;
+
+    public static Gyroscope gyro => UnityEngine.Input.gyro;
+
+    public static AccelerationEvent[] accelerationEvents => UnityEngine.Input.accelerationEvents;
+}
+
+#endif

package/WebGL/Input/Input.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 939a03910bfa04f1c9b087403c48fa77
+timeCreated: 1711364426

package/WebGL/Input/TTPCInputHandler.cs

@@ -0,0 +1,199 @@
+#if UNITY_WEBGL && !UNITY_EDITOR
+  #define TT_PC_INPUT
+#endif
+
+using System;
+using UnityEngine;
+
+#if TT_PC_INPUT
+using System.Runtime.InteropServices;
+using AOT;
+#endif
+
+namespace TTSDK
+{
+    public class TTPCInputHandler
+    {
+#if UNITY_EDITOR
+        public const string NotImplMessage = "TT Desktop Input API not supported on Unity Editor. Test it with Douyin App.";
+#elif UNITY_ANDROID
+        public const string NotImplMessage = "TT Desktop Input API not supported on Android Native.";
+#else
+        public const string NotImplMessage = "TT Desktop Input API supported on current platform.";
+#endif
+        
+        #region APIs
+        
+        public static bool TT_SetCursor(string path, double x, double y)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+        
+        public static void TT_RequestPointerLock()
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+        
+        public static bool TT_IsPointerLocked()
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+        
+        public static void TT_ExitPointerLock()
+        { 
+            throw new NotSupportedException(NotImplMessage);
+        }
+        #endregion
+      
+        #region Callback Delegate
+        
+        internal delegate void TTIntPtrCallback(IntPtr ptr);
+        
+        #endregion
+        
+        #region Callback OnKeyDown
+
+        private static void TT_RegisterKeyDownCallback(TTIntPtrCallback callback)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+#if TT_PC_INPUT
+        [MonoPInvokeCallback(typeof(TTIntPtrCallback))]
+#endif
+        private static void _OnKeyDownCallback(IntPtr ptr)
+        {
+            _onKeyDownCallback.Invoke(ptr);
+        }
+
+        private static Action<IntPtr> _onKeyDownCallback;
+        public static void SetOnKeyDownCallback(Action<IntPtr> callback)
+        {
+            _onKeyDownCallback = callback;
+            TT_RegisterKeyDownCallback(_onKeyDownCallback != null ? _OnKeyDownCallback : null);
+        }
+        
+        #endregion
+        
+        #region Callback OnKeyUp
+
+        private static void TT_RegisterKeyUpCallback(TTIntPtrCallback callback)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+#if TT_PC_INPUT
+        [MonoPInvokeCallback(typeof(TTIntPtrCallback))]
+#endif
+        private static void _OnKeyUpCallback(IntPtr ptr)
+        {
+            _onKeyUpCallback.Invoke(ptr);
+        }
+
+        private static Action<IntPtr> _onKeyUpCallback;
+        public static void SetOnKeyUpCallback(Action<IntPtr> callback)
+        {
+            _onKeyUpCallback = callback;
+            TT_RegisterKeyUpCallback(_onKeyUpCallback != null ? _OnKeyUpCallback : null);
+        }
+        
+        #endregion
+        
+        #region Callback OnMouseDown
+
+        private static void TT_RegisterMouseDownCallback(TTIntPtrCallback callback)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+#if TT_PC_INPUT
+        [MonoPInvokeCallback(typeof(TTIntPtrCallback))]
+#endif
+        private static void _OnMouseDownCallback(IntPtr ptr)
+        {
+            _onMouseDownCallback.Invoke(ptr);
+        }
+
+        private static Action<IntPtr> _onMouseDownCallback;
+        public static void SetOnMouseDownCallback(Action<IntPtr> callback)
+        {
+            _onMouseDownCallback = callback;
+            TT_RegisterMouseDownCallback(_onMouseDownCallback != null ? _OnMouseDownCallback : null);
+        }
+        
+        #endregion
+        
+        #region Callback OnMouseUp
+
+        private static void TT_RegisterMouseUpCallback(TTIntPtrCallback callback)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+#if TT_PC_INPUT
+        [MonoPInvokeCallback(typeof(TTIntPtrCallback))]
+#endif
+        private static void _OnMouseUpCallback(IntPtr ptr)
+        {
+            _onMouseUpCallback.Invoke(ptr);
+        }
+
+        private static Action<IntPtr> _onMouseUpCallback;
+        public static void SetOnMouseUpCallback(Action<IntPtr> callback)
+        {
+            _onMouseUpCallback = callback;
+            TT_RegisterMouseUpCallback(_onMouseUpCallback != null ? _OnMouseUpCallback : null);
+        }
+        
+        #endregion
+        
+        #region Callback OnMouseMove
+
+        private static void TT_RegisterMouseMoveCallback(TTIntPtrCallback callback)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+#if TT_PC_INPUT
+        [MonoPInvokeCallback(typeof(TTIntPtrCallback))]
+#endif
+        private static void _OnMouseMoveCallback(IntPtr ptr)
+        {
+            _onMouseMoveCallback.Invoke(ptr);
+        }
+
+        private static Action<IntPtr> _onMouseMoveCallback;
+        public static void SetOnMouseMoveCallback(Action<IntPtr> callback)
+        {
+            _onMouseMoveCallback = callback;
+            TT_RegisterMouseMoveCallback(_onMouseMoveCallback != null ? _OnMouseMoveCallback : null);
+        }
+        
+        #endregion
+        
+        #region Callback OnWheel
+
+        private static void TT_RegisterWheelCallback(TTIntPtrCallback callback)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+#if TT_PC_INPUT
+        [MonoPInvokeCallback(typeof(TTIntPtrCallback))]
+#endif
+        private static void _OnWheelCallback(IntPtr ptr)
+        {
+            _onWheelCallback.Invoke(ptr);
+        }
+
+        private static Action<IntPtr> _onWheelCallback;
+        public static void SetOnWheelCallback(Action<IntPtr> callback)
+        {
+            _onWheelCallback = callback;
+            TT_RegisterWheelCallback(_onWheelCallback != null ? _OnWheelCallback : null);
+        }
+        
+        #endregion
+
+    }
+}

package/WebGL/Input/TTPCInputHandler.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 179477622711641f89273efe87e9f646
+timeCreated: 1733732611

package/WebGL/Input.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0ae381d9a53c74ccbbad569066325ed1
+timeCreated: 1711364418

package/WebGL/Network/TTUDPSocketHandler.cs

@@ -0,0 +1,130 @@
+#if UNITY_WEBGL && !UNITY_EDITOR
+  #define TT_UDP_ENABLED
+#endif
+
+using System;
+using UnityEngine;
+
+#if TT_UDP_ENABLED
+using System.Runtime.InteropServices;
+using AOT;
+#endif
+
+namespace TTSDK.Network
+{
+    public class TTUDPSocketHandler
+    {
+
+#if UNITY_EDITOR
+            public const string NotImplMessage = "TT UDP Socket not supported on Unity Editor. Test it with Douyin App.";
+#elif UNITY_ANDROID
+            public const string NotImplMessage = "TT UDP Socket not supported on Android Native.";
+#else
+            public const string NotImplMessage = "TT UDP Socket not supported on current platform.";
+#endif
+            
+        public delegate void StarkUDPSocketOnMessageCallback(string instanceId, IntPtr ptrMsg, int lenMsg,
+          IntPtr ptrLocalInfo, IntPtr ptrRemoteInfo);
+        public static string StarkCreateUDPSocket()
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+        
+        public static void StarkUDPSocketClose(string id)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+        
+        public static void StarkUDPSocketConnect(string id, string option)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+        public static void StarkUDPSocketOnClose(string id)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+        public static void StarkUDPSocketOffClose(string id)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+        
+        public static void StarkUDPSocketOnError(string id)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+        public static void StarkUDPSocketOffError(string id)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+        public static void StarkUDPSocketOnListening(string id)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+        public static void StarkUDPSocketOffListening(string id)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+        public static void StarkUDPSocketOnMessage(string id, bool needInfo)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+        
+        public static void StarkUDPSocketOffMessage(string id)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+        public static void StarkUDPSocketSend(string id, string data, string param)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+        
+        public static void StarkUDPSocketSend(string id, byte[] data, int dataLength, string param)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+        
+        public static void StarkUDPSocketSetTTL(string id, double ttl)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+        public static int StarkUDPSocketBind(string id, string param)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+        
+        public static void StarkUDPSocketDestroy(string id)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+        public static void StarkRegisterUDPSocketOnMessageCallback(StarkUDPSocketOnMessageCallback callback)
+        {
+            throw new NotSupportedException(NotImplMessage);
+        }
+
+#if TT_UDP_ENABLED
+        [MonoPInvokeCallback(typeof(StarkUDPSocketOnMessageCallback))]
+#endif
+        public static void _UDPSocketOnMessageCallback(string instanceId, IntPtr ptrMsg, int lenMsg,
+            IntPtr ptrLocalInfo, IntPtr ptrRemoteInfo)
+        {
+          _messageCallback.Invoke(instanceId, ptrMsg, lenMsg, ptrLocalInfo, ptrRemoteInfo);
+        }
+
+        private static Action<string, IntPtr, int, IntPtr, IntPtr> _messageCallback;
+        public static void SetTTUDPSocketMessageCallback(Action<string, IntPtr, int, IntPtr, IntPtr> callback)
+        {
+            _messageCallback = callback;
+            StarkRegisterUDPSocketOnMessageCallback(_UDPSocketOnMessageCallback);
+        }
+// #endif
+    }
+}

package/WebGL/Network/TTUDPSocketHandler.cs.meta

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

package/WebGL/Network.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 98a59f5acbb984d6fab14ccc27bf5533
+timeCreated: 1712131246

package/WebGL/TTAssetBundle.jslib

@@ -0,0 +1,33 @@
+mergeInto(LibraryManager.library, {
+    StarkAbfsCheckReady: function() {
+        if (!window.StarkSDK || !window.StarkSDK.abfs)
+            return false;
+        return window.StarkSDK.abfs.checkReady();
+    },
+    StarkAbfsRegisterAssetBundleUrl: function(ptr) {
+        if (!window.StarkSDK) return;
+        var url = UTF8ToString(ptr);
+        window.StarkSDK.abfs.registerAssetBundleUrl(url);
+    },
+    StarkAbfsUnregisterAssetBundleUrl: function(ptr) {
+        if (!window.StarkSDK) return;
+        var url = UTF8ToString(ptr);
+        window.StarkSDK.abfs.unregisterAssetBundleUrl(url);
+    },
+    StarkAbfsFetchBundleFromXHR: function(url, id, callback, needRetry) {
+        if (!window.StarkSDK) return false;
+        var _url = UTF8ToString(url);
+        var _id = UTF8ToString(id);
+        var _callback = function(code, message) {
+            try {
+                var len = lengthBytesUTF8(_id) + 1;
+                var idPtr = _malloc(len);
+                stringToUTF8(_id, idPtr, len);
+                dynCall("viii", callback, [idPtr, code, 0]);
+            } catch (e) {
+                console.error("[TTAssetBundle] fetch callback error:", e.message || e);
+            }
+        }
+        window.StarkSDK.abfs.fetchBundleFromXHR(_url, _id, _callback, needRetry);
+    }
+});

package/WebGL/TTAssetBundle.jslib.meta

@@ -0,0 +1,32 @@
+fileFormatVersion: 2
+guid: 6ba649b40692046109a358054f0488a3
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      WebGL: WebGL
+    second:
+      enabled: 1
+      settings: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: