import Coffee.Internal

Runtime/Internal/Extensions/CanvasExtensions.cs

@@ -0,0 +1,134 @@
+#if UNITY_2021_3_0 || UNITY_2021_3_1 || UNITY_2021_3_2 || UNITY_2021_3_3 || UNITY_2021_3_4 || UNITY_2021_3_5 || UNITY_2021_3_6 || UNITY_2021_3_7 || UNITY_2021_3_8 || UNITY_2021_3_9
+#elif UNITY_2021_3_10 || UNITY_2021_3_11 || UNITY_2021_3_12 || UNITY_2021_3_13 || UNITY_2021_3_14 || UNITY_2021_3_15 || UNITY_2021_3_16 || UNITY_2021_3_17 || UNITY_2021_3_18 || UNITY_2021_3_19
+#elif UNITY_2021_3_20 || UNITY_2021_3_21 || UNITY_2021_3_22 || UNITY_2021_3_23 || UNITY_2021_3_24 || UNITY_2021_3_25 || UNITY_2021_3_26 || UNITY_2021_3_27 || UNITY_2021_3_28 || UNITY_2021_3_29
+#elif UNITY_2021_3_30 || UNITY_2021_3_31 || UNITY_2021_3_32 || UNITY_2021_3_33
+#elif UNITY_2022_2_0 || UNITY_2022_2_1 || UNITY_2022_2_2 || UNITY_2022_2_3 || UNITY_2022_2_4 || UNITY_2022_2_5 || UNITY_2022_2_6 || UNITY_2022_2_7 || UNITY_2022_2_8 || UNITY_2022_2_9
+#elif UNITY_2022_2_10 || UNITY_2022_2_11 || UNITY_2022_2_12 || UNITY_2022_2_13 || UNITY_2022_2_14
+#elif UNITY_2021_3 || UNITY_2022_2 || UNITY_2022_3 || UNITY_2023_2_OR_NEWER
+#define CANVAS_SUPPORT_ALWAYS_GAMMA
+#endif
+
+using UnityEngine;
+using UnityEngine.Profiling;
+#if UNITY_MODULE_VR
+using UnityEngine.XR;
+#endif
+
+namespace Coffee.UIParticleInternal
+{
+    internal static class CanvasExtensions
+    {
+        public static bool ShouldGammaToLinearInShader(this Canvas canvas)
+        {
+            return QualitySettings.activeColorSpace == ColorSpace.Linear &&
+#if CANVAS_SUPPORT_ALWAYS_GAMMA
+                   canvas.vertexColorAlwaysGammaSpace;
+#else
+                   false;
+#endif
+        }
+
+        public static bool ShouldGammaToLinearInMesh(this Canvas canvas)
+        {
+            return QualitySettings.activeColorSpace == ColorSpace.Linear &&
+#if CANVAS_SUPPORT_ALWAYS_GAMMA
+                   !canvas.vertexColorAlwaysGammaSpace;
+#else
+                   true;
+#endif
+        }
+
+        public static bool IsStereoCanvas(this Canvas canvas)
+        {
+#if UNITY_MODULE_VR
+            if (FrameCache.TryGet<bool>(canvas, nameof(IsStereoCanvas), out var stereo)) return stereo;
+
+            stereo =
+                canvas != null && canvas.renderMode != RenderMode.ScreenSpaceOverlay && canvas.worldCamera != null
+                && XRSettings.enabled && !string.IsNullOrEmpty(XRSettings.loadedDeviceName);
+            FrameCache.Set(canvas, nameof(IsStereoCanvas), stereo);
+            return stereo;
+#else
+            return false;
+#endif
+        }
+
+        /// <summary>
+        /// Gets the view-projection matrix for a Canvas.
+        /// </summary>
+        public static void GetViewProjectionMatrix(this Canvas canvas, out Matrix4x4 vpMatrix)
+        {
+            canvas.GetViewProjectionMatrix(Camera.MonoOrStereoscopicEye.Mono, out vpMatrix);
+        }
+
+        /// <summary>
+        /// Gets the view-projection matrix for a Canvas.
+        /// </summary>
+        public static void GetViewProjectionMatrix(this Canvas canvas, Camera.MonoOrStereoscopicEye eye,
+            out Matrix4x4 vpMatrix)
+        {
+            if (FrameCache.TryGet(canvas, nameof(GetViewProjectionMatrix), out vpMatrix)) return;
+
+            canvas.GetViewProjectionMatrix(eye, out var viewMatrix, out var projectionMatrix);
+            vpMatrix = viewMatrix * projectionMatrix;
+            FrameCache.Set(canvas, nameof(GetViewProjectionMatrix), vpMatrix);
+        }
+
+        /// <summary>
+        /// Gets the view and projection matrices for a Canvas.
+        /// </summary>
+        public static void GetViewProjectionMatrix(this Canvas canvas, out Matrix4x4 vMatrix, out Matrix4x4 pMatrix)
+        {
+            canvas.GetViewProjectionMatrix(Camera.MonoOrStereoscopicEye.Mono, out vMatrix, out pMatrix);
+        }
+
+        /// <summary>
+        /// Gets the view and projection matrices for a Canvas.
+        /// </summary>
+        public static void GetViewProjectionMatrix(this Canvas canvas, Camera.MonoOrStereoscopicEye eye,
+            out Matrix4x4 vMatrix, out Matrix4x4 pMatrix)
+        {
+            if (FrameCache.TryGet(canvas, "GetViewMatrix", (int)eye, out vMatrix) &&
+                FrameCache.TryGet(canvas, "GetProjectionMatrix", (int)eye, out pMatrix))
+            {
+                return;
+            }
+
+            // Get view and projection matrices.
+            Profiler.BeginSample("(COF)[CanvasExt] GetViewProjectionMatrix");
+            var rootCanvas = canvas.rootCanvas;
+            var cam = rootCanvas.worldCamera;
+            if (rootCanvas && rootCanvas.renderMode != RenderMode.ScreenSpaceOverlay && cam)
+            {
+                if (eye == Camera.MonoOrStereoscopicEye.Mono)
+                {
+                    vMatrix = cam.worldToCameraMatrix;
+                    pMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, false);
+                }
+                else
+                {
+                    pMatrix = cam.GetStereoProjectionMatrix((Camera.StereoscopicEye)eye);
+                    vMatrix = cam.GetStereoViewMatrix((Camera.StereoscopicEye)eye);
+                    pMatrix = GL.GetGPUProjectionMatrix(pMatrix, false);
+                }
+            }
+            else
+            {
+                var pos = rootCanvas.transform.position;
+                vMatrix = Matrix4x4.TRS(
+                    new Vector3(-pos.x, -pos.y, -1000),
+                    Quaternion.identity,
+                    new Vector3(1, 1, -1f));
+                pMatrix = Matrix4x4.TRS(
+                    new Vector3(0, 0, -1),
+                    Quaternion.identity,
+                    new Vector3(1 / pos.x, 1 / pos.y, -2 / 10000f));
+            }
+
+            FrameCache.Set(canvas, "GetViewMatrix", (int)eye, vMatrix);
+            FrameCache.Set(canvas, "GetProjectionMatrix", (int)eye, pMatrix);
+
+            Profiler.EndSample();
+        }
+    }
+}

Runtime/Internal/Extensions/CanvasExtensions.cs.meta

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

Runtime/Internal/Extensions/Color32Extensions.cs

@@ -0,0 +1,77 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Profiling;
+
+namespace Coffee.UIParticleInternal
+{
+    internal static class Color32Extensions
+    {
+        private static readonly List<Color32> s_Colors = new List<Color32>();
+        private static byte[] s_LinearToGammaLut;
+        private static byte[] s_GammaToLinearLut;
+
+        public static byte LinearToGamma(this byte self)
+        {
+            if (s_LinearToGammaLut == null)
+            {
+                s_LinearToGammaLut = new byte[256];
+                for (var i = 0; i < 256; i++)
+                {
+                    s_LinearToGammaLut[i] = (byte)(Mathf.LinearToGammaSpace(i / 255f) * 255f);
+                }
+            }
+
+            return s_LinearToGammaLut[self];
+        }
+
+        public static byte GammaToLinear(this byte self)
+        {
+            if (s_GammaToLinearLut == null)
+            {
+                s_GammaToLinearLut = new byte[256];
+                for (var i = 0; i < 256; i++)
+                {
+                    s_GammaToLinearLut[i] = (byte)(Mathf.GammaToLinearSpace(i / 255f) * 255f);
+                }
+            }
+
+            return s_GammaToLinearLut[self];
+        }
+
+        public static void LinearToGamma(this Mesh self)
+        {
+            Profiler.BeginSample("(COF)[ColorExt] LinearToGamma (Mesh)");
+            self.GetColors(s_Colors);
+            var count = s_Colors.Count;
+            for (var i = 0; i < count; i++)
+            {
+                var c = s_Colors[i];
+                c.r = c.r.LinearToGamma();
+                c.g = c.g.LinearToGamma();
+                c.b = c.b.LinearToGamma();
+                s_Colors[i] = c;
+            }
+
+            self.SetColors(s_Colors);
+            Profiler.EndSample();
+        }
+
+        public static void GammaToLinear(this Mesh self)
+        {
+            Profiler.BeginSample("(COF)[ColorExt] GammaToLinear (Mesh)");
+            self.GetColors(s_Colors);
+            var count = s_Colors.Count;
+            for (var i = 0; i < count; i++)
+            {
+                var c = s_Colors[i];
+                c.r = c.r.GammaToLinear();
+                c.g = c.g.GammaToLinear();
+                c.b = c.b.GammaToLinear();
+                s_Colors[i] = c;
+            }
+
+            self.SetColors(s_Colors);
+            Profiler.EndSample();
+        }
+    }
+}

Runtime/Internal/Extensions/Color32Extensions.cs.meta

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

Runtime/Internal/Extensions/ComponentExtensions.cs

@@ -0,0 +1,198 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Profiling;
+using Object = UnityEngine.Object;
+
+namespace Coffee.UIParticleInternal
+{
+    /// <summary>
+    /// Extension methods for Component class.
+    /// </summary>
+    internal static class ComponentExtensions
+    {
+        /// <summary>
+        /// Get components in children of a specific type in the hierarchy of a GameObject.
+        /// </summary>
+        public static T[] GetComponentsInChildren<T>(this Component self, int depth)
+            where T : Component
+        {
+            var results = ListPool<T>.Rent();
+            self.GetComponentsInChildren_Internal(results, depth);
+            var array = results.ToArray();
+            ListPool<T>.Return(ref results);
+            return array;
+        }
+
+        /// <summary>
+        /// Get components in children of a specific type in the hierarchy of a GameObject.
+        /// </summary>
+        public static void GetComponentsInChildren<T>(this Component self, List<T> results, int depth)
+            where T : Component
+        {
+            results.Clear();
+            self.GetComponentsInChildren_Internal(results, depth);
+        }
+
+        private static void GetComponentsInChildren_Internal<T>(this Component self, List<T> results, int depth)
+            where T : Component
+        {
+            if (!self || results == null || depth < 0) return;
+
+            var tr = self.transform;
+            if (tr.TryGetComponent<T>(out var t))
+            {
+                results.Add(t);
+            }
+
+            if (depth - 1 < 0) return;
+            var childCount = tr.childCount;
+            for (var i = 0; i < childCount; i++)
+            {
+                tr.GetChild(i).GetComponentsInChildren_Internal(results, depth - 1);
+            }
+        }
+
+        /// <summary>
+        /// Get or add a component of a specific type to a GameObject.
+        /// </summary>
+        public static T GetOrAddComponent<T>(this Component self) where T : Component
+        {
+            if (!self) return null;
+            return self.TryGetComponent<T>(out var component)
+                ? component
+                : self.gameObject.AddComponent<T>();
+        }
+
+        /// <summary>
+        /// Get the root component of a specific type in the hierarchy of a GameObject.
+        /// </summary>
+        public static T GetRootComponent<T>(this Component self) where T : Component
+        {
+            T component = null;
+            var transform = self.transform;
+            while (transform)
+            {
+                if (transform.TryGetComponent<T>(out var c))
+                {
+                    component = c;
+                }
+
+                transform = transform.parent;
+            }
+
+            return component;
+        }
+
+        /// <summary>
+        /// Get a component of a specific type in the parent hierarchy of a GameObject.
+        /// </summary>
+        public static T GetComponentInParent<T>(this Component self, bool includeSelf, Transform stopAfter,
+            Predicate<T> valid)
+            where T : Component
+        {
+            var tr = includeSelf ? self.transform : self.transform.parent;
+            while (tr)
+            {
+                if (tr.TryGetComponent<T>(out var c) && valid(c)) return c;
+                if (tr == stopAfter) return null;
+                tr = tr.parent;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Add a component of a specific type to the children of a GameObject.
+        /// </summary>
+        public static void AddComponentOnChildren<T>(this Component self, HideFlags hideFlags, bool includeSelf)
+            where T : Component
+        {
+            if (self == null) return;
+
+            Profiler.BeginSample("(COF)[ComponentExt] AddComponentOnChildren > Self");
+            if (includeSelf && !self.TryGetComponent<T>(out _))
+            {
+                var c = self.gameObject.AddComponent<T>();
+                c.hideFlags = hideFlags;
+            }
+
+            Profiler.EndSample();
+
+            Profiler.BeginSample("(COF)[ComponentExt] AddComponentOnChildren > Child");
+            var childCount = self.transform.childCount;
+            for (var i = 0; i < childCount; i++)
+            {
+                var child = self.transform.GetChild(i);
+                if (child.TryGetComponent<T>(out _)) continue;
+
+                var c = child.gameObject.AddComponent<T>();
+                c.hideFlags = hideFlags;
+            }
+
+            Profiler.EndSample();
+        }
+
+#if !UNITY_2021_2_OR_NEWER && !UNITY_2020_3_45 && !UNITY_2020_3_46 && !UNITY_2020_3_47 && !UNITY_2020_3_48
+        public static T GetComponentInParent<T>(this Component self, bool includeInactive) where T : Component
+        {
+            if (!self) return null;
+            if (!includeInactive) return self.GetComponentInParent<T>();
+
+            var current = self.transform;
+            while (current)
+            {
+                if (current.TryGetComponent<T>(out var c)) return c;
+                current = current.parent;
+            }
+
+            return null;
+        }
+#endif
+
+#if UNITY_EDITOR
+        /// <summary>
+        /// Verify whether it can be converted to the specified component.
+        /// </summary>
+        internal static bool CanConvertTo<T>(this Object context) where T : MonoBehaviour
+        {
+            return context && context.GetType() != typeof(T);
+        }
+
+        /// <summary>
+        /// Convert to the specified component.
+        /// </summary>
+        internal static void ConvertTo<T>(this Object context) where T : MonoBehaviour
+        {
+            var target = context as MonoBehaviour;
+            if (target == null) return;
+
+            var so = new SerializedObject(target);
+            so.Update();
+
+            var oldEnable = target.enabled;
+            target.enabled = false;
+
+            // Find MonoScript of the specified component.
+            foreach (var script in Resources.FindObjectsOfTypeAll<MonoScript>())
+            {
+                if (script.GetClass() != typeof(T))
+                {
+                    continue;
+                }
+
+                // Set 'm_Script' to convert.
+                so.FindProperty("m_Script").objectReferenceValue = script;
+                so.ApplyModifiedProperties();
+                break;
+            }
+
+            if (so.targetObject is MonoBehaviour mb)
+            {
+                mb.enabled = oldEnable;
+            }
+        }
+#endif
+    }
+}

Runtime/Internal/Extensions/ComponentExtensions.cs.meta

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

Runtime/Internal/Extensions/GraphicExtensions.cs

@@ -0,0 +1,125 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Profiling;
+using UnityEngine.UI;
+
+namespace Coffee.UIParticleInternal
+{
+    /// <summary>
+    /// Extension methods for Graphic class.
+    /// </summary>
+    internal static class GraphicExtensions
+    {
+        private static readonly Vector3[] s_WorldCorners = new Vector3[4];
+        private static readonly Bounds s_ScreenBounds = new Bounds(new Vector3(0.5f, 0.5f, 0.5f), new Vector3(1, 1, 1));
+
+        /// <summary>
+        /// Check if a Graphic component is currently in the screen view.
+        /// </summary>
+        public static void GetMaterialsForRendering(this Graphic self, List<Material> result)
+        {
+            result.Clear();
+            if (!self) return;
+
+            var cr = self.canvasRenderer;
+            var count = cr.materialCount;
+            var popCount = cr.popMaterialCount;
+
+            if (result.Capacity < count + popCount)
+            {
+                result.Capacity = count + popCount;
+            }
+
+            for (var i = 0; i < count; i++)
+            {
+                result.Add(cr.GetMaterial(i));
+            }
+
+            for (var i = 0; i < popCount; i++)
+            {
+                result.Add(cr.GetPopMaterial(i));
+            }
+        }
+
+        /// <summary>
+        /// Check if a Graphic component is currently in the screen view.
+        /// </summary>
+        public static bool IsInScreen(this Graphic self)
+        {
+            if (!self || !self.canvas) return false;
+
+            if (FrameCache.TryGet(self, nameof(IsInScreen), out bool result))
+            {
+                return result;
+            }
+
+            Profiler.BeginSample("(COF)[GraphicExt] IsInScreen");
+            var cam = self.canvas.renderMode != RenderMode.ScreenSpaceOverlay
+                ? self.canvas.worldCamera
+                : null;
+            var min = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
+            var max = new Vector3(float.MinValue, float.MinValue, float.MinValue);
+            self.rectTransform.GetWorldCorners(s_WorldCorners);
+            var screenSize = GetScreenSize();
+            for (var i = 0; i < 4; i++)
+            {
+                if (cam)
+                {
+                    s_WorldCorners[i] = cam.WorldToViewportPoint(s_WorldCorners[i]);
+                }
+                else
+                {
+                    s_WorldCorners[i] = RectTransformUtility.WorldToScreenPoint(null, s_WorldCorners[i]);
+                    s_WorldCorners[i].x /= screenSize.x;
+                    s_WorldCorners[i].y /= screenSize.y;
+                }
+
+                s_WorldCorners[i].z = 0;
+                min = Vector3.Min(s_WorldCorners[i], min);
+                max = Vector3.Max(s_WorldCorners[i], max);
+            }
+
+            var bounds = new Bounds(min, Vector3.zero);
+            bounds.Encapsulate(max);
+            result = bounds.Intersects(s_ScreenBounds);
+            FrameCache.Set(self, nameof(IsInScreen), result);
+            Profiler.EndSample();
+
+            return result;
+        }
+
+        /// <summary>
+        /// Get the actual main texture of a Graphic component.
+        /// </summary>
+        public static Texture GetActualMainTexture(this Graphic self)
+        {
+            var image = self as Image;
+            if (image == null) return self.mainTexture;
+
+            var sprite = image.overrideSprite;
+            return sprite ? sprite.GetActualTexture() : self.mainTexture;
+        }
+
+        private static Vector2Int GetScreenSize()
+        {
+#if UNITY_EDITOR
+            if (!Application.isPlaying && !Camera.current)
+            {
+                var res = UnityStats.screenRes.Split('x');
+                return new Vector2Int(int.Parse(res[0]), int.Parse(res[1]));
+            }
+#endif
+            return new Vector2Int(Screen.width, Screen.height);
+        }
+
+        public static float GetParentGroupAlpha(this Graphic self)
+        {
+            var alpha = self.canvasRenderer.GetAlpha();
+            if (Mathf.Approximately(alpha, 0)) return 1;
+
+            var inheritedAlpha = self.canvasRenderer.GetInheritedAlpha();
+            return Mathf.Clamp01(inheritedAlpha / alpha);
+        }
+    }
+}

Runtime/Internal/Extensions/GraphicExtensions.cs.meta

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

Runtime/Internal/Extensions/Misc.cs

@@ -0,0 +1,48 @@
+using System.Diagnostics;
+using UnityEditor;
+using UnityEngine;
+
+namespace Coffee.UIParticleInternal
+{
+    internal static class Misc
+    {
+        public static void Destroy(Object obj)
+        {
+            if (!obj) return;
+#if UNITY_EDITOR
+            if (!Application.isPlaying)
+            {
+                Object.DestroyImmediate(obj);
+            }
+            else
+#endif
+            {
+                Object.Destroy(obj);
+            }
+        }
+
+        public static void DestroyImmediate(Object obj)
+        {
+            if (!obj) return;
+#if UNITY_EDITOR
+            if (Application.isEditor)
+            {
+                Object.DestroyImmediate(obj);
+            }
+            else
+#endif
+            {
+                Object.Destroy(obj);
+            }
+        }
+
+        [Conditional("UNITY_EDITOR")]
+        public static void SetDirty(Object obj)
+        {
+#if UNITY_EDITOR
+            if (!obj) return;
+            EditorUtility.SetDirty(obj);
+#endif
+        }
+    }
+}

Runtime/Internal/Extensions/Misc.cs.meta

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

Runtime/Internal/Extensions/SpriteExtensions.cs

@@ -0,0 +1,58 @@
+using System;
+using UnityEngine;
+using UnityEngine.U2D;
+#if UNITY_EDITOR
+using System.Reflection;
+#endif
+
+namespace Coffee.UIParticleInternal
+{
+    /// <summary>
+    /// Extension methods for Sprite class.
+    /// </summary>
+    internal static class SpriteExtensions
+    {
+#if UNITY_EDITOR
+        private static readonly Type s_SpriteEditorExtensionType =
+            Type.GetType("UnityEditor.Experimental.U2D.SpriteEditorExtension, UnityEditor")
+            ?? Type.GetType("UnityEditor.U2D.SpriteEditorExtension, UnityEditor");
+
+        private static readonly MethodInfo s_GetActiveAtlasTextureMethod = s_SpriteEditorExtensionType
+            .GetMethod("GetActiveAtlasTexture", BindingFlags.Static | BindingFlags.NonPublic);
+
+        private static readonly MethodInfo s_GetActiveAtlasMethod = s_SpriteEditorExtensionType
+            .GetMethod("GetActiveAtlas", BindingFlags.Static | BindingFlags.NonPublic);
+
+        /// <summary>
+        /// Get the actual texture of a sprite in play mode or edit mode.
+        /// </summary>
+        public static Texture2D GetActualTexture(this Sprite self)
+        {
+            if (!self) return null;
+
+            if (Application.isPlaying) return self.texture;
+
+            var ret = s_GetActiveAtlasTextureMethod.Invoke(null, new object[] { self }) as Texture2D;
+            return ret ? ret : self.texture;
+        }
+
+        /// <summary>
+        /// Get the active sprite atlas of a sprite in play mode or edit mode.
+        /// </summary>
+        public static SpriteAtlas GetActiveAtlas(this Sprite self)
+        {
+            if (!self) return null;
+
+            return s_GetActiveAtlasMethod.Invoke(null, new object[] { self }) as SpriteAtlas;
+        }
+#else
+        /// <summary>
+        /// Get the actual texture of a sprite in play mode.
+        /// </summary>
+        internal static Texture2D GetActualTexture(this Sprite self)
+        {
+            return self ? self.texture : null;
+        }
+#endif
+    }
+}

Runtime/Internal/Extensions/SpriteExtensions.cs.meta

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

Runtime/Internal/Extensions/Vector3Extensions.cs

@@ -0,0 +1,46 @@
+using UnityEngine;
+
+namespace Coffee.UIParticleInternal
+{
+    internal static class Vector3Extensions
+    {
+        public static Vector3 Inverse(this Vector3 self)
+        {
+            self.x = Mathf.Approximately(self.x, 0) ? 1 : 1 / self.x;
+            self.y = Mathf.Approximately(self.y, 0) ? 1 : 1 / self.y;
+            self.z = Mathf.Approximately(self.z, 0) ? 1 : 1 / self.z;
+            return self;
+        }
+
+        public static Vector3 GetScaled(this Vector3 self, Vector3 other1)
+        {
+            self.Scale(other1);
+            return self;
+        }
+
+        public static Vector3 GetScaled(this Vector3 self, Vector3 other1, Vector3 other2)
+        {
+            self.Scale(other1);
+            self.Scale(other2);
+            return self;
+        }
+
+        public static Vector3 GetScaled(this Vector3 self, Vector3 other1, Vector3 other2, Vector3 other3)
+        {
+            self.Scale(other1);
+            self.Scale(other2);
+            self.Scale(other3);
+            return self;
+        }
+
+        public static bool IsVisible(this Vector3 self)
+        {
+            return 0 < Mathf.Abs(self.x * self.y * self.z);
+        }
+
+        public static bool IsVisible2D(this Vector3 self)
+        {
+            return 0 < Mathf.Abs(self.x * self.y);
+        }
+    }
+}

Runtime/Internal/Extensions/Vector3Extensions.cs.meta

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