com.xd.sdk.tap 0.0.6-xd.1

package/Core/Runtime/Internal/UI/Base/GraphicRaycasterBugFixed.cs

@@ -0,0 +1,240 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.Serialization;
+using UnityEngine.UI;
+
+namespace  TapTap.UI
+{
+    /// <summary>
+    /// 修复UnityUGui中Canvas画布在Windows平台宽高比过长（横屏拉很长）导致UI的最右边一部分无法被点击的Bug,现发现与2021.3.x版本
+    /// </summary>
+    public class GraphicRaycasterBugFixed : GraphicRaycaster
+    {
+        [NonSerialized] private List<Graphic> m_RaycastResults = new List<Graphic>();
+        private Canvas _Canvas;
+        private Canvas canvasBugFixed
+        {
+            get
+            {
+                if (_Canvas != null)
+                    return _Canvas;
+     
+                _Canvas = GetComponent<Canvas>();
+                return _Canvas;
+            }
+        }
+        /// <summary>
+        /// Perform the raycast against the list of graphics associated with the Canvas.
+        /// </summary>
+        /// <param name="eventData">Current event data</param>
+        /// <param name="resultAppendList">List of hit objects to append new results to.</param>
+        public override void Raycast(PointerEventData eventData, List<RaycastResult> resultAppendList)
+        {
+            if (canvasBugFixed == null)
+                return;
+     
+            var canvasGraphics = GraphicRegistry.GetGraphicsForCanvas(canvasBugFixed);
+            if (canvasGraphics == null || canvasGraphics.Count == 0)
+                return;
+     
+            int displayIndex;
+            var currentEventCamera = eventCamera; // Property can call Camera.main, so cache the reference
+     
+            if (canvasBugFixed.renderMode == RenderMode.ScreenSpaceOverlay || currentEventCamera == null)
+                displayIndex = canvasBugFixed.targetDisplay;
+            else
+                displayIndex = currentEventCamera.targetDisplay;
+     
+            //!! 不同之处
+            var eventPosition = Display.RelativeMouseAt(eventData.position); 
+            //MultipleDisplayUtilities.RelativeMouseAtScaled(eventData.position);
+            if (eventPosition != Vector3.zero)
+            {
+                // We support multiple display and display identification based on event position.
+     
+                int eventDisplayIndex = (int)eventPosition.z;
+     
+                // Discard events that are not part of this display so the user does not interact with multiple displays at once.
+                if (eventDisplayIndex != displayIndex)
+                    return;
+            }
+            else
+            {
+                // The multiple display system is not supported on all platforms, when it is not supported the returned position
+                // will be all zeros so when the returned index is 0 we will default to the event data to be safe.
+                eventPosition = eventData.position;
+
+                // We dont really know in which display the event occured. We will process the event assuming it occured in our display.
+            }
+     
+            // Convert to view space
+            Vector2 pos;
+            if (currentEventCamera == null)
+            {
+                // Multiple display support only when not the main display. For display 0 the reported
+                // resolution is always the desktops resolution since its part of the display API,
+                // so we use the standard none multiple display method. (case 741751)
+                float w = Screen.width;
+                float h = Screen.height;
+                if (displayIndex > 0 && displayIndex < Display.displays.Length)
+                {
+                    w = Display.displays[displayIndex].systemWidth;
+                    h = Display.displays[displayIndex].systemHeight;
+                }
+                pos = new Vector2(eventPosition.x / w, eventPosition.y / h);
+            }
+            else
+                pos = currentEventCamera.ScreenToViewportPoint(eventPosition);
+     
+            // If it's outside the camera's viewport, do nothing
+            if (pos.x < 0f || pos.x > 1f || pos.y < 0f || pos.y > 1f)
+                return;
+     
+            float hitDistance = float.MaxValue;
+     
+            Ray ray = new Ray();
+     
+            if (currentEventCamera != null)
+                ray = currentEventCamera.ScreenPointToRay(eventPosition);
+     
+            if (canvasBugFixed.renderMode != RenderMode.ScreenSpaceOverlay && blockingObjects != BlockingObjects.None)
+            {
+                float distanceToClipPlane = 100.0f;
+     
+                if (currentEventCamera != null)
+                {
+                    float projectionDirection = ray.direction.z;
+                    distanceToClipPlane = Mathf.Approximately(0.0f, projectionDirection)
+                        ? Mathf.Infinity
+                        : Mathf.Abs((currentEventCamera.farClipPlane - currentEventCamera.nearClipPlane) / projectionDirection);
+                }
+    #if PACKAGE_PHYSICS
+                    if (blockingObjects == BlockingObjects.ThreeD || blockingObjects == BlockingObjects.All)
+                    {
+                        if (ReflectionMethodsCache.Singleton.raycast3D != null)
+                        {
+                            var hits = ReflectionMethodsCache.Singleton.raycast3DAll(ray, distanceToClipPlane, (int)m_BlockingMask);
+                            if (hits.Length > 0)
+                                hitDistance = hits[0].distance;
+                        }
+                    }
+    #endif
+    #if PACKAGE_PHYSICS2D
+                    if (blockingObjects == BlockingObjects.TwoD || blockingObjects == BlockingObjects.All)
+                    {
+                        if (ReflectionMethodsCache.Singleton.raycast2D != null)
+                        {
+                            var hits = ReflectionMethodsCache.Singleton.getRayIntersectionAll(ray, distanceToClipPlane, (int)m_BlockingMask);
+                            if (hits.Length > 0)
+                                hitDistance = hits[0].distance;
+                        }
+                    }
+    #endif
+            }
+     
+            m_RaycastResults.Clear();
+     
+            Raycast(canvasBugFixed, currentEventCamera, eventPosition, canvasGraphics, m_RaycastResults);
+     
+            int totalCount = m_RaycastResults.Count;
+            for (var index = 0; index < totalCount; index++)
+            {
+                var go = m_RaycastResults[index].gameObject;
+                bool appendGraphic = true;
+     
+                if (ignoreReversedGraphics)
+                {
+                    if (currentEventCamera == null)
+                    {
+                        // If we dont have a camera we know that we should always be facing forward
+                        var dir = go.transform.rotation * Vector3.forward;
+                        appendGraphic = Vector3.Dot(Vector3.forward, dir) > 0;
+                    }
+                    else
+                    {
+                        // If we have a camera compare the direction against the cameras forward.
+                        var cameraForward = currentEventCamera.transform.rotation * Vector3.forward * currentEventCamera.nearClipPlane;
+                        // !!不同之处
+                        appendGraphic = Vector3.Dot(go.transform.position - currentEventCamera.transform.position - cameraForward, go.transform.forward) >= 0;
+                    }
+                }
+     
+                if (appendGraphic)
+                {
+                    float distance = 0;
+                    Transform trans = go.transform;
+                    Vector3 transForward = trans.forward;
+     
+                    if (currentEventCamera == null || canvasBugFixed.renderMode == RenderMode.ScreenSpaceOverlay)
+                        distance = 0;
+                    else
+                    {
+                        // http://geomalgorithms.com/a06-_intersect-2.html
+                        distance = (Vector3.Dot(transForward, trans.position - ray.origin) / Vector3.Dot(transForward, ray.direction));
+     
+                        // Check to see if the go is behind the camera.
+                        if (distance < 0)
+                            continue;
+                    }
+     
+                    if (distance >= hitDistance)
+                        continue;
+     
+                    var castResult = new RaycastResult
+                    {
+                        gameObject = go,
+                        module = this,
+                        distance = distance,
+                        screenPosition = eventPosition,
+                        displayIndex = displayIndex,
+                        index = resultAppendList.Count,
+                        depth = m_RaycastResults[index].depth,
+                        sortingLayer = canvasBugFixed.sortingLayerID,
+                        sortingOrder = canvasBugFixed.sortingOrder,
+                        worldPosition = ray.origin + ray.direction * distance,
+                        worldNormal = -transForward
+                    };
+                    resultAppendList.Add(castResult);
+                }
+            }
+        }
+        /// <summary>
+        /// Perform a raycast into the screen and collect all graphics underneath it.
+        /// </summary>
+        [NonSerialized] static readonly List<Graphic> s_SortedGraphics = new List<Graphic>();
+        private static void Raycast(Canvas canvas, Camera eventCamera, Vector2 pointerPosition, IList<Graphic> foundGraphics, List<Graphic> results)
+        {
+            // Necessary for the event system
+            int totalCount = foundGraphics.Count;
+            for (int i = 0; i < totalCount; ++i)
+            {
+                Graphic graphic = foundGraphics[i];
+     
+                // -1 means it hasn't been processed by the canvas, which means it isn't actually drawn
+                if (!graphic.raycastTarget || graphic.canvasRenderer.cull || graphic.depth == -1)
+                    continue;
+     
+                if (!RectTransformUtility.RectangleContainsScreenPoint(graphic.rectTransform, pointerPosition, eventCamera))
+                    continue;
+     
+                if (eventCamera != null && eventCamera.WorldToScreenPoint(graphic.rectTransform.position).z > eventCamera.farClipPlane)
+                    continue;
+     
+                if (graphic.Raycast(pointerPosition, eventCamera))
+                {
+                    s_SortedGraphics.Add(graphic);
+                }
+            }
+     
+            s_SortedGraphics.Sort((g1, g2) => g2.depth.CompareTo(g1.depth));
+            totalCount = s_SortedGraphics.Count;
+            for (int i = 0; i < totalCount; ++i)
+                results.Add(s_SortedGraphics[i]);
+     
+            s_SortedGraphics.Clear();
+        }
+    }
+}

package/Core/Runtime/Internal/UI/Base/GraphicRaycasterBugFixed.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 39341cb1058fe4bdebd02bc59f5c08e1
+timeCreated: 1678941027

package/Core/Runtime/Internal/UI/Base/LoadingPanelController.cs

@@ -0,0 +1,29 @@
+using UnityEngine;
+
+namespace TapSDK.UI
+{
+    public class LoadingPanelController : BasePanelController
+    {
+        public Transform rotater;
+
+        public float speed = 10;
+        /// <summary>
+        /// bind ugui components for every panel
+        /// </summary>
+        protected override void BindComponents()
+        {
+            rotater = transform.Find("Image");;
+        }
+
+        private void Update()
+        {
+            if (rotater != null)
+            {
+                var localEuler = rotater.localEulerAngles;
+                var z = rotater.localEulerAngles.z;
+                z += Time.deltaTime * speed;
+                rotater.localEulerAngles = new Vector3(localEuler.x, localEuler.y, z);
+            }
+        }
+    }
+}

package/Core/Runtime/Internal/UI/Base/LoadingPanelController.cs.meta

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

package/Core/Runtime/Internal/UI/Base/MonoSingleton.cs

@@ -0,0 +1,102 @@
+using System;
+using UnityEngine;
+
+namespace TapSDK.UI
+{
+    public class MonoSingleton<T> : MonoBehaviour where T : Component
+    {
+        private static T _instance;
+
+        public static T Instance
+        {
+            get
+            {
+                if (_instance == null && Application.isPlaying)
+                {
+                    CreateInstance();
+                }
+
+                return _instance;
+            }
+        }
+
+        private static void CreateInstance()
+        {
+            Type theType = typeof(T);
+
+            _instance = (T)FindObjectOfType(theType);
+
+            if (_instance == null)
+            {
+                var go = new GameObject(typeof(T).Name);
+                _instance = go.AddComponent<T>();
+
+                GameObject rootObj = GameObject.Find("TapSDKSingletons");
+                if (rootObj == null)
+                {
+                    rootObj = new GameObject("TapSDKSingletons");
+                    DontDestroyOnLoad(rootObj);
+                }
+
+                go.transform.SetParent(rootObj.transform);
+            }
+        }
+
+        public static void DestroyInstance()
+        {
+            if (_instance != null)
+            {
+                Destroy(_instance.gameObject);
+            }
+        }
+
+        public static bool HasInstance()
+        {
+            return _instance != null;
+        }
+
+        protected virtual void Awake()
+        {
+            if (_instance != null && _instance.gameObject != gameObject)
+            {
+                if (Application.isPlaying)
+                {
+                    Destroy(gameObject);
+                }
+                else
+                {
+                    DestroyImmediate(gameObject); // UNITY_EDITOR
+                }
+
+                return;
+            }
+            else if (_instance == null)
+            {
+                _instance = GetComponent<T>();
+            }
+
+            DontDestroyOnLoad(gameObject);
+
+            Init();
+        }
+
+        protected virtual void OnDestroy()
+        {
+            Uninit();
+
+            if (_instance != null && _instance.gameObject == gameObject)
+            {
+                _instance = null;
+            }
+        }
+
+        public virtual void Init()
+        {
+        }
+
+        public virtual void Uninit()
+        {
+        }
+
+    }
+}

package/Core/Runtime/Internal/UI/Base/MonoSingleton.cs.meta

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

package/Core/Runtime/Internal/UI/Base/Singleton.cs

@@ -0,0 +1,29 @@
+using System;
+
+namespace TapSDK.UI
+{
+    public class Singleton<T> where T : class
+    {
+        private static T _instance;
+        private static readonly object _lock = new object();
+
+        public static T Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    lock (_lock)
+                    {
+                        if (_instance == null)
+                        {
+                            _instance = (T)Activator.CreateInstance(typeof(T), true);
+                        }
+                    }
+                }
+
+                return _instance;
+            }
+        }
+    }
+}

package/Core/Runtime/Internal/UI/Base/Singleton.cs.meta

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

package/Core/Runtime/Internal/UI/Base/TipPanelController.cs

@@ -0,0 +1,45 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace TapSDK.UI
+{
+    public class TipPanelOpenParam : AbstractOpenPanelParameter
+    {
+        public string text;
+
+        public Color textColor;
+
+        public TextAnchor textAnchor;
+
+        public TipPanelOpenParam(string text, Color textColor, TextAnchor textAnchor)
+        {
+            this.text = text;
+            this.textColor = textColor;
+            this.textAnchor = textAnchor;
+        }
+    }
+    public class TipPanelController : BasePanelController
+    {
+        public Text text;
+
+        protected override void BindComponents()
+        {
+            base.BindComponents();
+            text = transform.Find("Text").GetComponent<Text>();
+        }
+
+        protected override void OnLoadSuccess()
+        {
+            base.OnLoadSuccess();
+            TipPanelOpenParam param = this.openParam as TipPanelOpenParam;
+            if (param != null)
+            {
+                text.text = param.text;
+                text.color = param.textColor;
+                text.alignment = param.textAnchor;
+            }
+        }
+
+    }
+}

package/Core/Runtime/Internal/UI/Base/TipPanelController.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4bf8716943aca4601b13dfac46ccf44b
+timeCreated: 1690867588

package/Core/Runtime/Internal/UI/Base/ToastBlackPanelController.cs

@@ -0,0 +1,95 @@
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace TapSDK.UI {
+    public class ToastPanelOpenParam : AbstractOpenPanelParameter {
+        public float popupTime;
+
+        public string text;
+
+        public Texture icon;
+
+        public ToastPanelOpenParam(string text, float popupTime, Texture icon = null) {
+            this.text = text;
+            this.popupTime = popupTime;
+            this.icon = icon;
+        }
+    }
+    
+    public class ToastBlackPanelController : BasePanelController {
+        private const int MAX_CHAR_COUNT = 87;
+        private const float MIN_HORIZONTAL_LENGTH = 210;
+        private const float MAX_HORIZONTAL_LENGTH = 1252;
+        [HideInInspector]
+        public Text text;
+        [HideInInspector]
+        public RectTransform background;
+        [HideInInspector]
+        public LayoutGroup layout;
+        [HideInInspector]
+        public RawImage iconImage;
+        
+        public float fixVal;
+
+        public float animationTime;
+
+        [SerializeField]
+        private float sizeDeltaX = 50f;
+        
+        protected override void BindComponents() {
+            base.BindComponents();
+            background = transform.Find("Root/BGM") as RectTransform;
+            layout = background.transform.Find("Container").GetComponent<LayoutGroup>();
+            text = layout.transform.Find("Text").GetComponent<Text>();
+            iconImage = layout.transform.Find("Mask/Icon").GetComponent<RawImage>();
+            fadeAnimationTime = animationTime;
+        }
+
+        protected override void OnLoadSuccess() {
+            base.OnLoadSuccess();
+            ToastPanelOpenParam param = this.openParam as ToastPanelOpenParam;
+            if (param != null) {
+                
+                iconImage.gameObject.SetActive(param.icon != null);
+                layout.enabled = param.icon != null;
+                text.text = param.text;
+                bool overflow;
+                // test: 已登录账号:海绵宝宝和派大星一起在海边晒太阳海绵宝宝和派大星一起在海边晒太阳海绵宝宝和派大星一起在海边晒太阳海绵宝宝和派大星一起在海边晒太阳海绵宝宝和派大星一起在海边边...
+                var totalLength = CalculateLengthOfText(out overflow);
+                if (overflow) {
+                    bool haveIcon = param.icon != null;
+                    int length = Mathf.Min(MAX_CHAR_COUNT - (haveIcon ? 4 : 0), param.text.Length - 1);
+                    var transformedText = param.text.Substring(0, length) + "...";
+                    text.text = transformedText;
+                }
+                var x = totalLength;
+                var y = background.sizeDelta.y;
+                background.sizeDelta = new Vector2(x, y);
+                var textRect = text.transform as RectTransform;
+                
+                if (param.icon != null) {
+                    iconImage.texture = param.icon;
+                    text.alignment = TextAnchor.MiddleLeft;
+                    textRect.sizeDelta = new Vector2(x - sizeDeltaX, 24);
+                }
+                else {
+                    text.alignment = TextAnchor.MiddleCenter;
+                    textRect.anchoredPosition = Vector2.zero;
+                    textRect.anchorMin = Vector2.zero;
+                    textRect.anchorMax = Vector2.one;
+                    textRect.sizeDelta = Vector2.zero;
+                }
+                this.Invoke("Close", param.popupTime);
+            }
+        }
+
+        protected float CalculateLengthOfText( out bool horizontalOverflow) {
+            var width = text.preferredWidth + fixVal + 12;
+            width = Mathf.Max(MIN_HORIZONTAL_LENGTH, width);
+            var maxWidth = MAX_HORIZONTAL_LENGTH;
+            horizontalOverflow = width > maxWidth;
+            width = Mathf.Min(maxWidth, width);
+            return width;
+        }
+    }
+}

package/Core/Runtime/Internal/UI/Base/ToastBlackPanelController.cs.meta

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

package/Core/Runtime/Internal/UI/Base/ToastWhitePanelController.cs

@@ -0,0 +1,79 @@
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace TapSDK.UI {
+    public class ToastWhitePanelController : BasePanelController {
+        private const int MAX_CHAR_COUNT = 69;
+        private const float MIN_HORIZONTAL_LENGTH = 120;
+        private const float MAX_HORIZONTAL_LENGTH = 1252;
+        private const float BACKGROUND_WIDTH_HELPER = 60;
+        [HideInInspector]
+        public Text text;
+        [HideInInspector]
+        public RectTransform background;
+        [HideInInspector]
+        public RawImage iconImage;
+        
+        public float fixVal;
+
+        public float animationTime;
+
+        public ToastPanelOpenParam toastParam;
+
+        protected override void BindComponents() {
+            base.BindComponents();
+            background = transform.Find("Root/BGM") as RectTransform;
+            text = background.transform.Find("Container/Text").GetComponent<Text>();
+            iconImage = background.transform.Find("Container/Image").GetComponent<RawImage>();
+            fadeAnimationTime = animationTime;
+        }
+
+        protected override void OnLoadSuccess() {
+            base.OnLoadSuccess();
+            ToastPanelOpenParam param = this.openParam as ToastPanelOpenParam;
+            toastParam = param;
+            if (param != null) {
+                iconImage.gameObject.SetActive(param.icon != null);
+                text.text = param.text;
+                bool overflow = text.text.Length > MAX_CHAR_COUNT;
+                // test: 已登录账号:海绵宝宝和派大星一起在海边晒太阳海绵宝宝和派大星一起在海边晒太阳海绵宝宝和派大星一起在海边晒太阳海绵宝宝和派大星一起在海边晒太阳海绵宝宝和派大星一起在海边边...
+                var totalLength = CalculateLengthOfText();
+                if (overflow) {
+                    bool haveIcon = param.icon != null;
+                    int length = Mathf.Min(MAX_CHAR_COUNT - (haveIcon ? 4 : 0), param.text.Length - 1);
+                    var transformedText = param.text.Substring(0, length) + "...";
+                    text.text = transformedText;
+                }
+                var x = totalLength;
+                var y = background.sizeDelta.y;
+                background.sizeDelta = new Vector2(x + BACKGROUND_WIDTH_HELPER, y);
+                var textRect = text.transform as RectTransform;
+                
+                if (param.icon != null) {
+                    iconImage.texture = param.icon;
+                    textRect.sizeDelta = new Vector2(x, y);
+                }
+                else {
+                    textRect.anchoredPosition = Vector2.zero;
+                    textRect.anchorMin = Vector2.zero;
+                    textRect.anchorMax = Vector2.one;
+                    textRect.sizeDelta = Vector2.zero;
+                }
+                this.Invoke("Close", param.popupTime);
+            }
+        }
+
+        private float CalculateLengthOfText() {
+            var width = text.preferredWidth + fixVal;
+            width = Mathf.Max(MIN_HORIZONTAL_LENGTH, width);
+            var maxWidth = MAX_HORIZONTAL_LENGTH;
+            width = Mathf.Min(maxWidth, width);
+            return width;
+        }
+
+        public void Refresh(float refreshTime) {
+            this.CancelInvoke("Close");
+            this.Invoke("Close", refreshTime);
+        }
+    }
+}

package/Core/Runtime/Internal/UI/Base/ToastWhitePanelController.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5e2bbf05d8861431bb645d167b1ab76c
+timeCreated: 1695367197