chore(release): 4.11.2 [skip ci]

## [4.11.2](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.11.1...v4.11.2) (2025-03-15)

### Bug Fixes

* IL2CPP build fails on older versions of Unity ([0da6525](0da652520c))
* NRE on enable ([0cff50e](0cff50ef69)), closes [#359](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/359)

.coffee.internal.sed

@@ -0,0 +1 @@
+s/Coffee.Internal/Coffee.UIParticleInternal/g

.releaserc.json

@@ -4,7 +4,7 @@
     "release-4.x",
     {
       "name": "release-preview",
-      "prerelease": true
+      "prerelease": "preview"
     }
   ],
   "plugins": [

CHANGELOG.md

@@ -1,3 +1,167 @@
+## [4.11.2](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.11.1...v4.11.2) (2025-03-15)
+
+
+### Bug Fixes
+
+* IL2CPP build fails on older versions of Unity ([0da6525](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/0da652520cd165b43de7404c0b0ab1fbcf9349d1))
+* NRE on enable ([0cff50e](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/0cff50ef696aa53fb7c46a9a737b7cf3a05b7b9b)), closes [#359](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/359)
+
+## [4.11.1](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.11.0...v4.11.1) (2025-02-21)
+
+
+### Bug Fixes
+
+* component icons will no longer be displayed in the scene view ([6dfbdae](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/6dfbdae38d3822ab9c2c6f0e4ca1ca32ee98a239))
+
+# [4.11.0](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.10.7...v4.11.0) (2025-02-21)
+
+
+### Features
+
+* add 'TimeScaleMultiplier' option ([925af0b](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/925af0b6046f65f23a778f67cefa8ff9cbedb513))
+
+## [4.10.7](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.10.6...v4.10.7) (2025-01-14)
+
+
+### Bug Fixes
+
+* editor crashed on exit play mode (editor, windows) ([47ee45c](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/47ee45cbbe651a8f87ca2b8a3948f8b88db8211e)), closes [#351](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/351)
+
+## [4.10.6](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.10.5...v4.10.6) (2025-01-03)
+
+
+### Bug Fixes
+
+* sub-emitter particles may not render correctly in certain scenarios ([8276684](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/8276684c3b1646f0490ed64557547ba15281664a)), closes [#348](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/348)
+* sub-emitter's `inherit velocity` module doubles at runtime ([67de3d1](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/67de3d1bd3e16dc9b564625cb990c53d75769506)), closes [#349](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/349)
+
+## [4.10.5](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.10.4...v4.10.5) (2024-12-23)
+
+
+### Bug Fixes
+
+* '3D' scale toggle in the inspector does not keep on reload ([934f4b8](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/934f4b8f1c61f8ff20228d0ebcea9f636a3758ed)), closes [#346](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/346)
+
+## [4.10.4](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.10.3...v4.10.4) (2024-12-19)
+
+
+### Bug Fixes
+
+* rendering issues when playing with opening a prefab stage ([95235a9](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/95235a929b82cf681365ed6eba837d857f83e3d2)), closes [#345](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/345)
+
+## [4.10.3](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.10.2...v4.10.3) (2024-11-20)
+
+
+### Bug Fixes
+
+* if not configured as a preloaded asset, the project settings asset will be regenerated ([abe0948](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/abe09485f65dd4efd18e74675e752e0213bdf3be)), closes [#342](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/342)
+
+## [4.10.2](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.10.1...v4.10.2) (2024-11-01)
+
+
+### Bug Fixes
+
+* trail incorrect offset ([afe00a1](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/afe00a1dde80eb1c0a7bb668b75f4c3733d3fa43)), closes [#335](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/335)
+
+## [4.10.1](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.10.0...v4.10.1) (2024-09-29)
+
+
+### Bug Fixes
+
+* mainTex will be ignored ([2ee69d0](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/2ee69d04245fabce185f67dc9bd68c870e556564))
+
+# [4.10.0](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.9.1...v4.10.0) (2024-09-29)
+
+
+### Bug Fixes
+
+* component icon is not set ([5ff6ec8](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/5ff6ec815a174de5d3f16d424f1204c60912a8d8))
+
+
+### Features
+
+* add project settings ([1ce4e31](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/1ce4e31a9681bf1a201d2723c8d97e07ecc16592))
+
+## [4.9.1](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.9.0...v4.9.1) (2024-08-07)
+
+
+### Bug Fixes
+
+* ParticleSystem trails gain offset on parent canvas change ([2a1cd50](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/2a1cd502b452b5b56edf8bcfe91adf99d1bb5147)), closes [#323](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/323)
+
+# [4.9.0](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.8.1...v4.9.0) (2024-07-18)
+
+
+### Features
+
+* ParticleAttractor supports multiple ParticleSystems ([3834780](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/3834780fdb43443fe6e1ef89df54d26a24d62a91))
+
+## [4.8.1](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.8.0...v4.8.1) (2024-06-27)
+
+
+### Bug Fixes
+
+* remove debug code ([669deb4](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/669deb41d4ac589d9db93b29bc8e95383e7f28a5))
+
+# [4.8.0](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.7.2...v4.8.0) (2024-06-27)
+
+
+### Bug Fixes
+
+* generated baking-camera object remains in the prefab or scene (again) ([de35cba](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/de35cba34c6312c1405ed522e9927c620c78e72d))
+* SetParticleSystemInstance/Prefab APIs destroy generated objects ([ae3f3a8](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/ae3f3a8e62cc733420354d237ab765ac777127c8))
+
+
+### Features
+
+* add 'custom view' option. ([a703c29](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/a703c2921ca08c2280d0c8fde01e4c0b33b5c69e))
+* remove overlay window (editor) ([8358170](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/835817049f4fcf00dd2bf98dbada14f041ad3544))
+* restore `Transform.localScale` when setting `autoScalingMode` to something other than `Transform` (again) ([88a970d](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/88a970d93a2b69cf011d86bd1807569e90538e0e))
+* the rendering order list in inspector is now more compact ([be90172](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/be901724e064befacf617f4940b0331e1d31e1ca))
+
+## [4.7.2](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.7.1...v4.7.2) (2024-06-21)
+
+
+### Bug Fixes
+
+* generated baking-camera object remains in the prefab or scene ([0bb8438](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/0bb843830197d8c1252232928becc211c0ada08d))
+
+## [4.7.1](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.7.0...v4.7.1) (2024-06-20)
+
+
+### Bug Fixes
+
+* despite not using the size module, particles become smaller based on their z position ([a8ed6e6](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/a8ed6e68584e1d9e45ed852eefcc03979ea7e0e1)), closes [#316](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/316)
+
+# [4.7.0](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.6.8...v4.7.0) (2024-06-19)
+
+
+### Bug Fixes
+
+* `UIParticle.transform.localScale` does not scale particles ([1d40e24](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/1d40e24c742741e97f03c55468ccb1e505341133)), closes [#313](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/313)
+* UIParticle is scaled by canvas size even when `AutoScalingMode.None` and `ScalingMode.Local` ([54a4b1c](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/54a4b1cdfd06400c7be89c1ee704bb42a659c7c2)), closes [#313](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/313)
+* UIParticle is scaled incorrectly with nested canvases ([f26920f](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/f26920f9825547222a4afbb31cc5dc5a002c3e9b)), closes [#313](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/313)
+
+
+### Features
+
+* reset previous position on start play for world space simulation ([3880484](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/3880484ce5190c42fc79c81d0b69e3fbeda09dd0)), closes [#303](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/303)
+* restore `Transform.localScale` when setting `autoScalingMode` to something other than `Transform` ([5505247](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/5505247a94a929ff89635fde512a9b95691e0043))
+
+## [4.6.8](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.6.7...v4.6.8) (2024-06-14)
+
+
+### Bug Fixes
+
+* 'Resource ID out of range in GetResource' error in overlay rendering mode ([05286ce](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/05286cedfd17b1a0cb90a5e918513644f47cd831)), closes [#308](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/308)
+
+## [4.6.7](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.6.6...v4.6.7) (2024-05-24)
+
+
+### Bug Fixes
+
+* the ParticleSystem's localPosition drifts at certain scales due to floating-point precision issues ([e924eb4](https://github.com/mob-sakai/ParticleEffectForUGUI/commit/e924eb45968a112347471cabaeabc274e4c37ce4)), closes [#299](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/299) [#312](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/312)
+
 ## [4.6.6](https://github.com/mob-sakai/ParticleEffectForUGUI/compare/v4.6.5...v4.6.6) (2024-05-23)
 
 

Editor/AnimatablePropertyEditor.cs

@@ -31,35 +31,35 @@ namespace Coffee.UIExtensions
             }
             else
             {
-                result.Aggregate(s_Sb, (a, b) => s_Sb.AppendFormat("{0}, ", b));
+                result.Aggregate(s_Sb, (a, b) =>
+                {
+                    s_Sb.Append(b);
+                    return s_Sb.Append(", ");
+                });
                 s_Sb.Length -= 2;
             }
 
             return s_Sb.ToString();
         }
 
-        public static void Draw(SerializedProperty sp, Material[] mats)
+        public static void Draw(SerializedProperty sp, List<Material> mats)
         {
-            bool isClicked;
-            using (new EditorGUILayout.HorizontalScope(GUILayout.ExpandWidth(false)))
-            {
-                var pos = EditorGUILayout.GetControlRect(true);
-                var label = new GUIContent(sp.displayName, sp.tooltip);
-                var rect = EditorGUI.PrefixLabel(pos, label);
-                var text = sp.hasMultipleDifferentValues
-                    ? "-"
-                    : CollectActiveNames(sp, s_ActiveNames);
-                isClicked = GUI.Button(rect, text, EditorStyles.popup);
-            }
+            var pos = EditorGUILayout.GetControlRect(true);
+            var label = new GUIContent(sp.displayName, sp.tooltip);
+            var rect = EditorGUI.PrefixLabel(pos, label);
+            var text = sp.hasMultipleDifferentValues
+                ? "-"
+                : CollectActiveNames(sp, s_ActiveNames);
 
-            if (!isClicked) return;
+            if (!GUI.Button(rect, text, EditorStyles.popup)) return;
 
             var gm = new GenericMenu();
-            gm.AddItem(s_ContentNothing, s_ActiveNames.Count == 0, () =>
+            gm.AddItem(s_ContentNothing, s_ActiveNames.Count == 0, x =>
             {
-                sp.ClearArray();
-                sp.serializedObject.ApplyModifiedProperties();
-            });
+                var current = (SerializedProperty)x;
+                current.ClearArray();
+                current.serializedObject.ApplyModifiedProperties();
+            }, sp);
 
             if (!sp.hasMultipleDifferentValues)
             {
@@ -73,7 +73,7 @@ namespace Coffee.UIExtensions
             }
 
             s_Names.Clear();
-            for (var j = 0; j < mats.Length; j++)
+            for (var j = 0; j < mats.Count; j++)
             {
                 var mat = mats[j];
                 if (!mat || !mat.shader) continue;
@@ -82,8 +82,7 @@ namespace Coffee.UIExtensions
                 {
                     var name = ShaderUtil.GetPropertyName(mat.shader, i);
                     var type = (AnimatableProperty.ShaderPropertyType)ShaderUtil.GetPropertyType(mat.shader, i);
-                    if (s_Names.Contains(name)) continue;
-                    s_Names.Add(name);
+                    if (!s_Names.Add(name)) continue;
 
                     AddMenu(gm, sp, new ShaderProperty(name, type), true);
 

Editor/UIParticleEditor.cs

@@ -5,8 +5,9 @@ using UnityEditor;
 using UnityEditor.UI;
 using UnityEditorInternal;
 using UnityEngine;
+using UnityEngine.Profiling;
 using UnityEngine.UI;
-using Coffee.UIParticleExtensions;
+using Coffee.UIParticleInternal;
 #if UNITY_2021_2_OR_NEWER
 using UnityEditor.Overlays;
 #else
@@ -16,6 +17,7 @@ using Object = UnityEngine.Object;
 #endif
 #if UNITY_2021_2_OR_NEWER
 using UnityEditor.SceneManagement;
+
 #elif UNITY_2018_3_OR_NEWER
 using UnityEditor.Experimental.SceneManagement;
 #endif
@@ -26,42 +28,29 @@ namespace Coffee.UIExtensions
     [CanEditMultipleObjects]
     internal class UIParticleEditor : GraphicEditor
     {
-#if UNITY_2021_2_OR_NEWER
-#if UNITY_2022_1_OR_NEWER
-        [Overlay(typeof(SceneView), "Scene View/UI Particles", "UI Particles", true,
-            defaultDockPosition = DockPosition.Bottom,
-            defaultDockZone = DockZone.Floating,
-            defaultLayout = Layout.Panel)]
-#else
-        [Overlay(typeof(SceneView), "Scene View/UI Particles", "UI Particles", true)]
-#endif
-        private class UIParticleOverlay : IMGUIOverlay, ITransientOverlay
+        internal class State : ScriptableSingleton<State>
         {
-            public bool visible => s_SerializedObject != null;
-
-            public override void OnGUI()
-            {
-                if (visible)
-                {
-                    WindowFunction();
-                }
-            }
+            public bool is3DScaleMode;
         }
-#endif
 
         //################################
         // Constant or Static Members.
         //################################
+        private static readonly GUIContent[] s_ContentMaterials = new[]
+        {
+            new GUIContent("Material"),
+            new GUIContent("Trail Material")
+        };
+
         private static readonly GUIContent s_ContentRenderingOrder = new GUIContent("Rendering Order");
         private static readonly GUIContent s_ContentRefresh = new GUIContent("Refresh");
         private static readonly GUIContent s_ContentFix = new GUIContent("Fix");
-        private static readonly GUIContent s_ContentMaterial = new GUIContent("Material");
-        private static readonly GUIContent s_ContentTrailMaterial = new GUIContent("Trail Material");
         private static readonly GUIContent s_Content3D = new GUIContent("3D");
         private static readonly GUIContent s_ContentRandom = new GUIContent("Random");
         private static readonly GUIContent s_ContentScale = new GUIContent("Scale");
-        private static SerializedObject s_SerializedObject;
-        private static bool s_XYZMode;
+        private static readonly GUIContent s_ContentPrimary = new GUIContent("Primary");
+        private static readonly Regex s_RegexBuiltInGuid = new Regex(@"^0{16}.0{15}$", RegexOptions.Compiled);
+        private static readonly List<Material> s_TempMaterials = new List<Material>();
 
         private SerializedProperty _maskable;
         private SerializedProperty _scale3D;
@@ -71,8 +60,12 @@ namespace Coffee.UIExtensions
         private SerializedProperty _groupMaxId;
         private SerializedProperty _positionMode;
         private SerializedProperty _autoScalingMode;
+        private SerializedProperty _useCustomView;
+        private SerializedProperty _customViewSize;
+        private SerializedProperty _timeScaleMultiplier;
         private ReorderableList _ro;
         private bool _showMax;
+        private bool _is3DScaleMode;
 
         private static readonly HashSet<Shader> s_Shaders = new HashSet<Shader>();
 #if UNITY_2018 || UNITY_2019
@@ -88,56 +81,6 @@ namespace Coffee.UIExtensions
             "_ColorMask"
         };
 
-        [InitializeOnLoadMethod]
-        private static void Init()
-        {
-#if !UNITY_2021_2_OR_NEWER
-            var miSceneViewOverlayWindow = Type.GetType("UnityEditor.SceneViewOverlay, UnityEditor")
-                ?.GetMethods(BindingFlags.Public | BindingFlags.Static)
-                .First(x => x.Name == "Window" && 5 <= x.GetParameters().Length);
-            var windowFunction = (Action<Object, SceneView>)WindowFunction;
-            var windowFunctionType = Type.GetType("UnityEditor.SceneViewOverlay+WindowFunction, UnityEditor");
-            var windowFunctionDelegate = Delegate.CreateDelegate(windowFunctionType, windowFunction.Method);
-            var windowTitle = new GUIContent(ObjectNames.NicifyVariableName(nameof(UIParticle)));
-#if UNITY_2019_2_OR_NEWER
-            //public static void Window(GUIContent title, WindowFunction sceneViewFunc, int order, Object target, WindowDisplayOption option, EditorWindow window = null)
-            var sceneViewArgs = new object[] { windowTitle, windowFunctionDelegate, 599, null, 2, null };
-#else
-            //public static void Window(GUIContent title, WindowFunction sceneViewFunc, int order, Object target, WindowDisplayOption option)
-            var sceneViewArgs = new object[] { windowTitle, windowFunctionDelegate, 599, null, 2 };
-#endif
-
-#if UNITY_2019_1_OR_NEWER
-            SceneView.duringSceneGui += _ =>
-#else
-            SceneView.onSceneGUIDelegate += _ =>
-#endif
-            {
-                if (s_SerializedObject != null)
-                {
-                    miSceneViewOverlayWindow.Invoke(null, sceneViewArgs);
-                }
-            };
-#endif
-
-            SerializedObject CreateSerializeObject()
-            {
-                var uiParticles = Selection.gameObjects.Select(x => x.GetComponent<ParticleSystem>())
-                    .Where(x => x)
-                    .Select(x => x.GetComponentInParent<UIParticle>(true))
-                    .Where(x => x && x.canvas)
-                    .Concat(Selection.gameObjects.Select(x => x.GetComponent<UIParticle>())
-                        .Where(x => x && x.canvas))
-                    .Distinct()
-                    .OfType<Object>()
-                    .ToArray();
-                return 0 < uiParticles.Length ? new SerializedObject(uiParticles) : null;
-            }
-
-            s_SerializedObject = CreateSerializeObject();
-            Selection.selectionChanged += () => s_SerializedObject = CreateSerializeObject();
-        }
-
         //################################
         // Public/Protected Members.
         //################################
@@ -156,31 +99,44 @@ namespace Coffee.UIExtensions
             _groupMaxId = serializedObject.FindProperty("m_GroupMaxId");
             _positionMode = serializedObject.FindProperty("m_PositionMode");
             _autoScalingMode = serializedObject.FindProperty("m_AutoScalingMode");
+            _useCustomView = serializedObject.FindProperty("m_UseCustomView");
+            _customViewSize = serializedObject.FindProperty("m_CustomViewSize");
+            _timeScaleMultiplier = serializedObject.FindProperty("m_TimeScaleMultiplier");
 
             var sp = serializedObject.FindProperty("m_Particles");
             _ro = new ReorderableList(sp.serializedObject, sp, true, true, true, true)
             {
-                elementHeight = EditorGUIUtility.singleLineHeight * 3 + 4,
-                elementHeightCallback = _ => 3 * (EditorGUIUtility.singleLineHeight + 2),
+                elementHeightCallback = index =>
+                {
+                    var ps = sp.GetArrayElementAtIndex(index).objectReferenceValue as ParticleSystem;
+                    var materialCount = 0;
+                    if (ps && ps.TryGetComponent<ParticleSystemRenderer>(out var psr))
+                    {
+                        materialCount = psr.sharedMaterials.Length;
+                    }
+
+                    return (materialCount + 1) * (EditorGUIUtility.singleLineHeight + 2);
+                },
                 drawElementCallback = (rect, index, _, __) =>
                 {
-                    EditorGUI.BeginDisabledGroup(sp.hasMultipleDifferentValues);
-                    rect.y += 1;
+                    rect.y += 2;
                     rect.height = EditorGUIUtility.singleLineHeight;
                     var p = sp.GetArrayElementAtIndex(index);
                     EditorGUI.ObjectField(rect, p, GUIContent.none);
+                    var ps = p.objectReferenceValue as ParticleSystem;
+                    if (!ps || !ps.TryGetComponent<ParticleSystemRenderer>(out var psr)) return;
+
                     rect.x += 15;
                     rect.width -= 15;
-                    var ps = p.objectReferenceValue as ParticleSystem;
-                    var materials = ps
-                        ? new SerializedObject(ps.GetComponent<ParticleSystemRenderer>()).FindProperty("m_Materials")
-                        : null;
-                    rect.y += rect.height + 1;
-                    MaterialField(rect, s_ContentMaterial, materials, 0);
-                    rect.y += rect.height + 1;
-                    MaterialField(rect, s_ContentTrailMaterial, materials, 1);
-                    EditorGUI.EndDisabledGroup();
-                    if (materials != null && materials.serializedObject.hasModifiedProperties)
+                    var materials = new SerializedObject(psr).FindProperty("m_Materials");
+                    var count = Mathf.Min(materials.arraySize, 2);
+                    for (var i = 0; i < count; i++)
+                    {
+                        rect.y += rect.height + 2;
+                        EditorGUI.PropertyField(rect, materials.GetArrayElementAtIndex(i), s_ContentMaterials[i]);
+                    }
+
+                    if (materials.serializedObject.hasModifiedProperties)
                     {
                         materials.serializedObject.ApplyModifiedProperties();
                     }
@@ -214,19 +170,18 @@ namespace Coffee.UIExtensions
                     uip.RefreshParticles(uip.particles);
                 }
             }
-        }
 
-        private static void MaterialField(Rect rect, GUIContent label, SerializedProperty sp, int index)
-        {
-            if (sp == null || sp.arraySize <= index)
+            // Initialize 3D scale mode.
+            _is3DScaleMode = State.instance.is3DScaleMode;
+            if (!_is3DScaleMode)
             {
-                EditorGUI.BeginDisabledGroup(true);
-                EditorGUI.ObjectField(rect, label, null, typeof(Material), true);
-                EditorGUI.EndDisabledGroup();
-            }
-            else
-            {
-                EditorGUI.PropertyField(rect, sp.GetArrayElementAtIndex(index), label);
+                var x = _scale3D.FindPropertyRelative("x");
+                var y = _scale3D.FindPropertyRelative("y");
+                var z = _scale3D.FindPropertyRelative("z");
+                _is3DScaleMode = !Mathf.Approximately(x.floatValue, y.floatValue) ||
+                                 !Mathf.Approximately(y.floatValue, z.floatValue) ||
+                                 y.hasMultipleDifferentValues ||
+                                 z.hasMultipleDifferentValues;
             }
         }
 
@@ -238,6 +193,7 @@ namespace Coffee.UIExtensions
             var current = target as UIParticle;
             if (!current) return;
 
+            Profiler.BeginSample("(UIP:E) OnInspectorGUI");
             serializedObject.Update();
 
             // Maskable
@@ -245,17 +201,16 @@ namespace Coffee.UIExtensions
 
             // Scale
             EditorGUI.BeginDisabledGroup(!_meshSharing.hasMultipleDifferentValues && _meshSharing.intValue == 4);
-            s_XYZMode = DrawFloatOrVector3Field(_scale3D, s_XYZMode);
+            if (DrawFloatOrVector3Field(_scale3D, _is3DScaleMode) != _is3DScaleMode)
+            {
+                State.instance.is3DScaleMode = _is3DScaleMode = !_is3DScaleMode;
+            }
+
             EditorGUI.EndDisabledGroup();
 
             // AnimatableProperties
-            var mats = current.particles
-                .Where(x => x)
-                .Select(x => x.GetComponent<ParticleSystemRenderer>().sharedMaterial)
-                .Where(x => x)
-                .ToArray();
-
-            AnimatablePropertyEditor.Draw(_animatableProperties, mats);
+            current.GetMaterials(s_TempMaterials);
+            AnimatablePropertyEditor.Draw(_animatableProperties, s_TempMaterials);
 
             // Mesh sharing
             EditorGUI.BeginChangeCheck();
@@ -263,9 +218,12 @@ namespace Coffee.UIExtensions
             if (EditorGUI.EndChangeCheck())
             {
                 serializedObject.ApplyModifiedProperties();
-                foreach (var uip in targets.OfType<UIParticle>())
+                foreach (var t in targets)
                 {
-                    uip.ResetGroupId();
+                    if (t is UIParticle uip)
+                    {
+                        uip.ResetGroupId();
+                    }
                 }
             }
 
@@ -273,16 +231,32 @@ namespace Coffee.UIExtensions
             EditorGUILayout.PropertyField(_positionMode);
 
             // Auto Scaling
-            DrawAutoScaling(_autoScalingMode, targets.OfType<UIParticle>());
+            EditorGUILayout.PropertyField(_autoScalingMode);
+
+            // Custom View Size
+            EditorGUILayout.PropertyField(_useCustomView);
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.BeginDisabledGroup(!_useCustomView.boolValue);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(_customViewSize);
+            EditorGUI.indentLevel--;
+            EditorGUI.EndDisabledGroup();
+            if (EditorGUI.EndChangeCheck())
+            {
+                _customViewSize.floatValue = Mathf.Max(0.1f, _customViewSize.floatValue);
+            }
+
+            // Time Scale Multiplier
+            EditorGUILayout.PropertyField(_timeScaleMultiplier);
 
             // Target ParticleSystems.
             EditorGUI.BeginChangeCheck();
-            EditorGUI.BeginDisabledGroup(targets.OfType<UIParticle>().Any(x => !x.canvas));
             _ro.DoLayoutList();
-            EditorGUI.EndDisabledGroup();
             serializedObject.ApplyModifiedProperties();
+
             if (EditorGUI.EndChangeCheck())
             {
+                EditorApplication.QueuePlayerLoopUpdate();
                 foreach (var uip in targets.OfType<UIParticle>())
                 {
                     uip.RefreshParticles(uip.particles);
@@ -290,7 +264,8 @@ namespace Coffee.UIExtensions
             }
 
             // Non-UI built-in shader is not supported.
-            foreach (var mat in current.materials)
+            Profiler.BeginSample("(UIP:E) Non-UI built-in shader is not supported.");
+            foreach (var mat in s_TempMaterials)
             {
                 if (!mat || !mat.shader) continue;
                 var shader = mat.shader;
@@ -303,15 +278,18 @@ namespace Coffee.UIExtensions
                 }
             }
 
+            Profiler.EndSample();
+
             // Does the shader support UI masks?
+            Profiler.BeginSample("(UIP:E) Does the shader support UI masks?");
             if (current.maskable && current.GetComponentInParent<Mask>(false))
             {
-                foreach (var mat in current.materials)
+                foreach (var mat in s_TempMaterials)
                 {
                     if (!mat || !mat.shader) continue;
                     var shader = mat.shader;
-                    if (s_Shaders.Contains(shader)) continue;
-                    s_Shaders.Add(shader);
+                    if (!s_Shaders.Add(shader)) continue;
+
                     foreach (var propName in s_MaskablePropertyNames)
                     {
                         if (mat.HasProperty(propName)) continue;
@@ -325,7 +303,9 @@ namespace Coffee.UIExtensions
                 }
             }
 
+            s_TempMaterials.Clear();
             s_Shaders.Clear();
+            Profiler.EndSample();
 
             // UIParticle for trail should be removed.
             var label = "This UIParticle component should be removed. The UIParticle for trails is no longer needed.";
@@ -364,12 +344,14 @@ namespace Coffee.UIExtensions
                 }
             }
 #endif
+            Profiler.EndSample();
         }
 
-        private bool IsBuiltInObject(Object obj)
+        private static bool IsBuiltInObject(Object obj)
         {
-            return AssetDatabase.TryGetGUIDAndLocalFileIdentifier(obj, out var guid, out long _)
-                   && Regex.IsMatch(guid, "^0{16}.0{15}$", RegexOptions.Compiled);
+            return AssetDatabase.IsMainAsset(obj)
+                   && AssetDatabase.TryGetGUIDAndLocalFileIdentifier(obj, out var guid, out long _)
+                   && s_RegexBuiltInGuid.IsMatch(guid);
         }
 
 #if UNITY_2018 || UNITY_2019
@@ -463,7 +445,7 @@ namespace Coffee.UIExtensions
             {
                 EditorGUI.BeginDisabledGroup(true);
                 var obj = UIParticleUpdater.GetPrimary(spGroupId.intValue);
-                EditorGUILayout.ObjectField("Primary", obj, typeof(UIParticle), false);
+                EditorGUILayout.ObjectField(s_ContentPrimary, obj, typeof(UIParticle), false);
                 EditorGUI.EndDisabledGroup();
             }
 
@@ -473,54 +455,9 @@ namespace Coffee.UIExtensions
             return showMax;
         }
 
-        private static void DrawAutoScaling(SerializedProperty prop, IEnumerable<UIParticle> uiParticles)
+        private static void DrawAutoScaling(SerializedProperty prop)
         {
-            var isTransformMode = prop.intValue == (int)UIParticle.AutoScalingMode.Transform;
-            EditorGUI.BeginChangeCheck();
             EditorGUILayout.PropertyField(prop);
-            if (!EditorGUI.EndChangeCheck() || !isTransformMode) return;
-
-            // on changed true->false, reset scale.
-            EditorApplication.delayCall += () =>
-            {
-                foreach (var uip in uiParticles)
-                {
-                    if (!uip) continue;
-                    uip.transform.localScale = Vector3.one;
-                }
-            };
-        }
-
-#if UNITY_2021_2_OR_NEWER
-        private static void WindowFunction()
-#else
-        private static void WindowFunction(Object _, SceneView __)
-#endif
-        {
-            try
-            {
-                if (s_SerializedObject == null || !s_SerializedObject.targetObject) return;
-                var uiParticles = s_SerializedObject.targetObjects.OfType<UIParticle>().ToArray();
-                if (uiParticles.Any(x => !x || !x.canvas)) return;
-
-                s_SerializedObject.Update();
-                using (new EditorGUILayout.VerticalScope(GUILayout.Width(220f)))
-                {
-                    var labelWidth = EditorGUIUtility.labelWidth;
-                    EditorGUIUtility.labelWidth = 100;
-                    EditorGUILayout.PropertyField(s_SerializedObject.FindProperty("m_Enabled"));
-                    s_XYZMode = DrawFloatOrVector3Field(s_SerializedObject.FindProperty("m_Scale3D"), s_XYZMode);
-                    EditorGUILayout.PropertyField(s_SerializedObject.FindProperty("m_PositionMode"));
-                    DrawAutoScaling(s_SerializedObject.FindProperty("m_AutoScalingMode"), uiParticles);
-                    EditorGUIUtility.labelWidth = labelWidth;
-                }
-
-                s_SerializedObject.ApplyModifiedProperties();
-            }
-            catch
-            {
-                // ignored
-            }
         }
 
         private void DestroyUIParticle(UIParticle p, bool ignoreCurrent = false)

LICENSE.md

@@ -1,4 +1,4 @@
-Copyright 2018-2023 mob-sakai
+Copyright 2018-2024 mob-sakai
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

README.md

@@ -1,61 +1,85 @@
-# Particle Effect For UGUI (UI Particle)
-
-This package provides a component to render particle effects for uGUI in Unity 2018.2 or later.  
-The particle rendering is maskable and sortable, without the need for an extra Camera, RenderTexture, or Canvas.
+# <img alt="UIParticleIcon" src="https://github.com/mob-sakai/ParticleEffectForUGUI/assets/12690315/d76e105e-a840-4f61-a1f6-8cf311c0812d" width="26"/> Particle Effect For UGUI (UI Particle) <!-- omit in toc -->
 
 [![](https://img.shields.io/npm/v/com.coffee.ui-particle?label=openupm&registry_uri=https://package.openupm.com)](https://openupm.com/packages/com.coffee.ui-particle/)
-[![](https://img.shields.io/github/v/release/mob-sakai/ParticleEffectForUGUI?include_prereleases)](https://github.com/mob-sakai/ParticleEffectForUGUI/releases)
-[![](https://img.shields.io/github/license/mob-sakai/ParticleEffectForUGUI.svg)](https://github.com/mob-sakai/ParticleEffectForUGUI/blob/main/LICENSE.txt)  
+[![](https://img.shields.io/github/v/release/mob-sakai/ParticleEffectForUGUI)](https://github.com/mob-sakai/ParticleEffectForUGUI/releases)
+[![](https://img.shields.io/github/license/mob-sakai/ParticleEffectForUGUI.svg)](https://github.com/mob-sakai/ParticleEffectForUGUI/blob/main/LICENSE.md)  
 ![](https://img.shields.io/badge/Unity-2018.2+-57b9d3.svg?style=flat&logo=unity)
+![](https://img.shields.io/badge/uGUI_2.0_Ready-57b9d3.svg?style=flat)
+![](https://img.shields.io/badge/UPR%2FHDPR_Ready-57b9d3.svg?style=flat)  
 ![](https://github.com/mob-sakai/ParticleEffectForUGUI/actions/workflows/test.yml/badge.svg?branch=develop)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-orange.svg)](http://makeapullrequest.com)
+[![](https://img.shields.io/github/watchers/mob-sakai/ParticleEffectForUGUI.svg?style=social&label=Watch)](https://github.com/mob-sakai/ParticleEffectForUGUI/subscription)
 [![](https://img.shields.io/twitter/follow/mob_sakai.svg?label=Follow&style=social)](https://twitter.com/intent/follow?screen_name=mob_sakai)
 
-<< [📝 Description](#-description) | [🎮 Demo](#-demo) | [⚙ Installation](#-installation) | [🚀 Usage](#-usage) | [🛠 Development Note](#-development-note) | [🤝 Contributing](#-contributing) >>
+<< [📝 Description](#-description-) | [📌 Key Features](#-key-features) | [🎮 Demo](#-demo) | [⚙ Installation](#-installation) | [🚀 Usage](#-usage) | [🛠 Development Note](#-development-note) | [🤝 Contributing](#-contributing) >>
 
-<br><br>
-
-## 📝 Description
+## 📝 Description <!-- omit in toc -->
 
 ![](https://user-images.githubusercontent.com/12690315/41771577-8da4b968-7650-11e8-9524-cd162c422d9d.gif)
 
-This package utilizes the new APIs `MeshBake/MashTrailBake` (introduced with Unity 2018.2) to render particles through
-CanvasRenderer.  
-You can render, mask, and sort your ParticleSystems for UI without the necessity of an additional Camera, RenderTexture,
-or Canvas.
+This package uses the new APIs `MeshBake/MeshTrailBake` (introduced in Unity 2018.2) to render particles through `CanvasRenderer`.  
+You can render, mask, and sort your `ParticleSystems` for UI without the need for an additional `Camera`, `RenderTexture`, or `Canvas`.
 
-### Features
+- [📌 Key Features](#-key-features)
+- [🎮 Demo](#-demo)
+- [⚙ Installation](#-installation)
+    - [Install via OpenUPM](#install-via-openupm)
+    - [Install via UPM (with Package Manager UI)](#install-via-upm-with-package-manager-ui)
+    - [Install via UPM (Manually)](#install-via-upm-manually)
+    - [Install as Embedded Package](#install-as-embedded-package)
+- [🚀 Usage](#-usage)
+  - [Component: UIParticle](#component-uiparticle)
+  - [Basic Usage](#basic-usage)
+  - [Usage with Your Existing ParticleSystem Prefab](#usage-with-your-existing-particlesystem-prefab)
+  - [Usage with `Mask` or `RectMask2D` Component](#usage-with-mask-or-rectmask2d-component)
+  - [Usage with Script](#usage-with-script)
+  - [Component: UIParticleAttractor](#component-uiparticleattractor)
+  - [Project Settings](#project-settings)
+- [🛠 Development Note](#-development-note)
+  - [Compares the Baking mesh approach with the conventional approach](#compares-the-baking-mesh-approach-with-the-conventional-approach)
+    - [Performance test results](#performance-test-results)
+  - [🔍 FAQ: Why Are My UIParticles Not Displayed Correctly?](#-faq-why-are-my-uiparticles-not-displayed-correctly)
+  - [Shader Limitation](#shader-limitation)
+    - [Built-in shaders are not supported](#built-in-shaders-are-not-supported)
+    - [(Unity 2018 or 2019) UV.zw components will be discarded](#unity-2018-or-2019-uvzw-components-will-be-discarded)
+    - [(Unity 2018 or 2019) Custom vertex streams](#unity-2018-or-2019-custom-vertex-streams)
+  - [Overheads](#overheads)
+  - [How to Make a Custom Shader to Support `Mask` and `RectMask2D` Component](#how-to-make-a-custom-shader-to-support-mask-and-rectmask2d-component)
+- [🤝 Contributing](#-contributing)
+  - [Issues](#issues)
+  - [Pull Requests](#pull-requests)
+  - [Support](#support)
+- [License](#license)
+- [Author](#author)
+- [See Also](#see-also)
 
-* Easy to use: The package is ready to use out of the box.
-* Sort particle effects and other UI by sibling index.
-* No extra Camera, RenderTexture, or Canvas required.
-* Masking options for Mask or RectMask2D.
-* Support for the Trail module.
-* Support for CanvasGroup alpha.
-* No allocations needed to render particles.
-* Compatibility with overlay, camera space, and world space.
-* Support for Universal Render Pipeline (URP) and High Definition Render Pipeline (HDRP).
-* Support for disabling `Enter Play Mode Options > Reload Domain`.
-* Support for changing material property with AnimationClip (AnimatableProperty).  
-  ![AnimatableProperty.gif][AnimatableProperty.gif]
-* [4.0.0+] Support for 8+ materials.
-* [4.0.0+] Correct world space particle position adjustment when changing window size for standalone platforms (Windows,
-  MacOSX, and Linux).
-* [4.0.0+] Adaptive scaling for UI.
-* [4.0.0+] Mesh sharing group to improve performance.  
-  ![MeshSharing.gif][MeshSharing.gif]
-* [4.0.0+] Particle attractor component.  
-  ![ParticleAttractor.gif][ParticleAttractor.gif]
-* [4.1.0+] Relative/Absolute particle position mode.  
-  ![AbsolutePosition.gif][AbsolutePosition.gif]
+<br><br>
 
-[AnimatableProperty.gif]: https://user-images.githubusercontent.com/12690315/53286323-2d94a980-37b0-11e9-8afb-c4a207805ff2.gif
+## 📌 Key Features
 
-[MeshSharing.gif]: https://user-images.githubusercontent.com/12690315/174311048-c882df81-6c34-4eba-b0aa-5645457692f1.gif
-
-[ParticleAttractor.gif]: https://user-images.githubusercontent.com/12690315/174311027-462929a4-13f0-4ec4-86ea-9c832f2eecf1.gif
-
-[AbsolutePosition.gif]: https://user-images.githubusercontent.com/12690315/175751579-5a2357e8-2ecf-4afd-83c8-66e9771bde39.gif
+* **Easy to use:** The package is ready to use out of the box.
+* **Sortable:** Sort particle effects and other UI elements by sibling index.
+* **Maskable:** Supports `Mask` or `RectMask2D`.
+* **No extra components required:** No need for an additional `Camera`, `RenderTexture`, or `Canvas`.
+* **Trail module support:** Fully supports the Trail module.
+* **CanvasGroup alpha support:** Integrates with `CanvasGroup` alpha.
+* **No allocations:** Efficiently renders particles without allocations.
+* **Any canvas render mode support:** Works with overlay, camera space, and world space.
+* **Any Render pipeline support:** Compatible with Universal Render Pipeline (URP) and High Definition Render Pipeline (HDRP).
+* **Disabling domain reload support:** Supports disabling `Enter Play Mode Options > Reload Domain`.
+* **Animatable material properties:** Supports changing material properties with AnimationClip (AnimatableProperty).  
+  ![AnimatableProperty.gif](https://user-images.githubusercontent.com/12690315/53286323-2d94a980-37b0-11e9-8afb-c4a207805ff2.gif)
+* **Multiple materials:** Supports 8+ materials.
+* **Correct positioning:** Adjusts world space particle positions correctly when changing window size for standalone platforms (Windows, MacOSX, and Linux).
+* **Adaptive scaling:** Provides adaptive scaling for UI (AutoScalingMode).
+* **Performance optimization:** Mesh sharing group to improve performance.  
+  <img alt="MeshSharing.gif" src="https://user-images.githubusercontent.com/12690315/174311048-c882df81-6c34-4eba-b0aa-5645457692f1.gif" width="450"/>
+* **Particle attractor:** Includes a particle attractor component.  
+  <img alt="ParticleAttractor.gif" src="https://user-images.githubusercontent.com/12690315/174311027-462929a4-13f0-4ec4-86ea-9c832f2eecf1.gif" width="450"/>
+* **Emission position mode:** Supports relative/absolute particle emission position modes.  
+  <img alt="AbsolutePosition.gif" src="https://user-images.githubusercontent.com/12690315/175751579-5a2357e8-2ecf-4afd-83c8-66e9771bde39.gif" width="450"/>
+* **Custom view size:** Fixes min/max particle size mismatch.  
+  ![CustomViewSize.gif](https://github.com/mob-sakai/ParticleEffectForUGUI/assets/12690315/dd929959-1a37-420b-b13d-e849022b9c9d)
 
 <br><br>
 
@@ -76,66 +100,87 @@ or Canvas.
 
 [JMO]: https://assetstore.unity.com/publishers/1669
 
-
 <br><br>
 
 ## ⚙ Installation
 
-_This package requires Unity 2018.3 or later._
+_This package requires **Unity 2018.3 or later**._
 
 #### Install via OpenUPM
 
-This package is available on [OpenUPM](https://openupm.com) package registry.
-This is the preferred method of installation, as you can easily receive updates as they're released.
+- This package is available on [OpenUPM](https://openupm.com) package registry.
+- This is the preferred method of installation, as you can easily receive updates as they're released.
+- If you have [openupm-cli](https://github.com/openupm/openupm-cli) installed, then run the following command in your project's directory:
+  ```
+  openupm add com.coffee.ui-particle
+  ```
+- To update the package, use Package Manager UI (`Window > Package Manager`) or run the following command with `@{version}`:
+  ```
+  openupm add com.coffee.ui-particle@4.9.0
+  ```
 
-If you have [openupm-cli](https://github.com/openupm/openupm-cli) installed, then run the following command in your
-project's directory:
+#### Install via UPM (with Package Manager UI)
 
-```sh
-openupm add com.coffee.ui-particle
-```
+- Click `Window > Package Manager` to open Package Manager UI.
+- Click `+ > Add package from git URL...` and input the repository URL: `https://github.com/mob-sakai/ParticleEffectForUGUI.git`  
+  ![](https://github.com/user-attachments/assets/f88f47ad-c606-44bd-9e86-ee3f72eac548)
+- To update the package, change suffix `#{version}` to the target version.
+  - e.g. `https://github.com/mob-sakai/ParticleEffectForUGUI.git#4.9.0`
 
-#### Install via UPM (using Git URL)
+#### Install via UPM (Manually)
 
-Navigate to your project's Packages folder and open the `manifest.json` file. Then add this package somewhere in
-the `dependencies` block:
-
-```json
-{
-  "dependencies": {
-    "com.coffee.ui-particle": "https://github.com/mob-sakai/ParticleEffectForUGUI.git",
-    ...
+- Open the `Packages/manifest.json` file in your project. Then add this package somewhere in the `dependencies` block:
+  ```json
+  {
+    "dependencies": {
+      "com.coffee.ui-particle": "https://github.com/mob-sakai/ParticleEffectForUGUI.git",
+      ...
+    }
   }
-}
-```
+  ```
 
-To update the package, change suffix `#{version}` to the target version.
+- To update the package, change suffix `#{version}` to the target version.
+  - e.g. `"com.coffee.ui-particle": "https://github.com/mob-sakai/ParticleEffectForUGUI.git#4.9.0",`
 
-* e.g. `"com.coffee.ui-particle": "https://github.com/mob-sakai/ParticleEffectForUGUI.git#4.6.0",`
+#### Install as Embedded Package
 
-Or, use [UpmGitExtension](https://github.com/mob-sakai/UpmGitExtension) to install and update the package.
+1. Download a source code zip file from [Releases](https://github.com/mob-sakai/ParticleEffectForUGUI.git/releases) and extract it.
+2. Place it in your project's `Packages` directory.  
+   ![](https://github.com/mob-sakai/mob-sakai/assets/12690315/0b7484b4-5fca-43b0-a9ef-e5dbd99bcdb4)
+- If you want to fix bugs or add features, install it as an embedded package.
+- To update the package, you need to re-download it and replace the contents.
 
 <br><br>
 
 ## 🚀 Usage
 
-### UIParticle Component
+### Component: UIParticle
 
 `UIParticle` controls the ParticleSystems that are attached to its own game objects and child game objects.
 
-![](https://github.com/mob-sakai/ParticleEffectForUGUI/assets/12690315/3559df45-63e7-4c4c-9233-f455779efa29)
+![](https://github.com/user-attachments/assets/bc9eb783-afce-4102-ac61-aee9ea8d6f2f)
 
-- **Maskable**: Does this graphic allow masking.
-- **Scale**: Scale the rendering. When the `3D` toggle is enabled, 3D scale (x, y, z) is supported.
+- **Maskable**: Does this graphic allow maskable.
+- **Scale**: Scale the rendering particles. When the `3D` toggle is enabled, 3D scale (x, y, z) is supported.
 - **Animatable Properties**: If you want to update material properties (e.g., `_MainTex_ST`, `_Color`) in AnimationClip,
-  use this to mark the changes.
+  use this to mark as animatable.
 - **Mesh Sharing**: Particle simulation results are shared within the same group. A large number of the same effects can
   be displayed with a small load. When the `Random` toggle is enabled, it will be grouped randomly.
+  - **None:** Disable mesh sharing.
+  - **Auto:** Automatically select Primary/Replica.
+  - **Primary:** Provides particle simulation results to the same group.
+  - **Primary Simulator:** Primary, but do not render the particle (simulation only).
+  - **Replica:** Render simulation results provided by the primary.
 - **Position Mode**: Emission position mode.
-    - **Absolute:** Emit from the world position of the `ParticleSystem`.
-    - **Relative:** Emit from the scaled position of the `ParticleSystem`.
-- **Auto Scaling**: `Transform.lossyScale` (=world scale) will be set to `(1, 1, 1)` on update. It prevents the
-  root-Canvas scale from affecting the hierarchy-scaled `ParticleSystem`.
+  - **Absolute:** The particles will be emitted from the world position.
+  - **Relative:** The particles will be emitted from the scaled position.
+- **Auto Scaling Mode**: How to automatically adjust when the Canvas scale is changed by the screen size or reference resolution.
+  - **None:** Do nothing.
+  - **Transform:** Transform.lossyScale (=world scale) will be set to (1, 1, 1).
+  - **UIParticle:** UIParticle.scale will be adjusted.
+- **Use Custom View:** Use this if the particles are not displayed correctly due to min/max particle size.
+  - **Custom view size:** Change the bake view size.
+- **Time Scale Multiplier:** Time scale multiplier.
 - **Rendering Order**: The ParticleSystem list to be rendered. You can change the order and the materials.
 
 **NOTE:** Press the `Refresh` button to reconstruct the rendering order based on children ParticleSystem's sorting order
@@ -143,7 +188,7 @@ and z-position.
 
 <br><br>
 
-#### Basic Usage
+### Basic Usage
 
 1. Select `GameObject/UI/ParticleSystem` to create UIParticle with a ParticleSystem.
    ![particle](https://user-images.githubusercontent.com/12690315/95007361-cad0e880-0649-11eb-8835-f145d62c5977.png)
@@ -152,7 +197,7 @@ and z-position.
 
 <br>
 
-#### With Your Existing ParticleSystem Prefab
+### Usage with Your Existing ParticleSystem Prefab
 
 1. Select `GameObject/UI/ParticleSystem (Empty)` to create UIParticle.
    ![empty](https://user-images.githubusercontent.com/12690315/95007362-cb697f00-0649-11eb-8a09-29b0a13791e4.png)
@@ -161,24 +206,25 @@ and z-position.
 
 <br>
 
-#### With `Mask` or `RectMask2D` Component
+### Usage with `Mask` or `RectMask2D` Component
 
 If you want to mask particles, set a stencil-supported shader (such as `UI/UIAdditive`) to the material for
 ParticleSystem.
 If you use some custom shaders, see
-the [How to Make a Custom Shader to Support Mask/RectMask2D Component](#how-to-make-a-custom-shader-to-support-maskrectmask2d-component)
+the [How to Make a Custom Shader to Support Mask/RectMask2D Component](#how-to-make-a-custom-shader-to-support-mask-and-rectmask2d-component)
 section.
 
 ![](https://user-images.githubusercontent.com/12690315/95017591-3b512700-0695-11eb-864e-04166ea1809a.png)
 
 <br><br>
 
-### Script usage
+### Usage with Script
 
 ```cs
-// Instant ParticleSystem prefab with UIParticle on runtime.
+// Instantiate ParticleSystem prefab with UIParticle on runtime.
 var go = GameObject.Instantiate(prefab);
 var uiParticle = go.AddComponent<UIParticle>();
+uiParticle.scale = 100;
 
 // Control by ParticleSystem.
 particleSystem.Play();
@@ -191,14 +237,14 @@ uiParticle.Stop();
 
 <br><br>
 
-### UIParticleAttractor component
+### Component: UIParticleAttractor
 
 `UIParticleAttractor` attracts particles generated by the specified ParticleSystem.
 
-![](https://github.com/mob-sakai/ParticleEffectForUGUI/assets/12690315/ea6ae0ed-f9a8-437c-8baa-47526303391e)  
+![](https://github.com/mob-sakai/ParticleEffectForUGUI/assets/12690315/5c20ad73-4b9a-4f38-9cdc-119df5cce077)
 ![](https://user-images.githubusercontent.com/12690315/174311027-462929a4-13f0-4ec4-86ea-9c832f2eecf1.gif)
 
-- **Particle System**: Attracts particles generated by the specified particle system.
+- **Particle Systems**: Attracts particles generated by the specified ParticleSystems.
 - **Destination Radius**: Once the particle is within the radius, the particle lifetime will become 0, and `OnAttracted`
   will be called.
 - **Delay Rate**: Delay to start attracting. It is a percentage of the particle's start lifetime.
@@ -212,6 +258,14 @@ uiParticle.Stop();
 
 <br><br>
 
+### Project Settings
+
+![](https://github.com/user-attachments/assets/befc7f34-fb47-4006-831a-eba79fda11ca)
+
+- Click `Edit > Project Settings` to open the Project Settings window and then select `UI > UI Particle` category.
+
+<br><br>
+
 ## 🛠 Development Note
 
 ### Compares the Baking mesh approach with the conventional approach
@@ -343,7 +397,7 @@ When improving performance, keep the following in mind:
     - Consider a single material, atlasing the sprites, and using `Sprite` mode in the `Texture Sheet Animation` module
       in the ParticleSystem.
 
-### How to Make a Custom Shader to Support Mask/RectMask2D Component
+### How to Make a Custom Shader to Support `Mask` and `RectMask2D` Component
 
 <details>
 <summary>Shader tips</summary>

Runtime/Coffee.UIParticle.R.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: 4d73b3825bf044d418ae21bb331d3902
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Internal.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 7a55e246f37df405bac88eac692e3a86
+guid: 53aa3f36032944b3fb1455e774c52396
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Runtime/Internal/Extensions.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8cf8018dee45a4c42a19eec890eaa5b1
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: d188d31b140094ebc84a9caafbc7ac71
+guid: 9dd767b8c0f95478386e7d5079cd44df
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

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

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: b0beae5bb1cb142b9ab90dc0d371f026
+guid: 0ef431b9df32c410ea5fa46be81def6b
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Runtime/Internal/Extensions/ComponentExtensions.cs

@@ -0,0 +1,227 @@
+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 = InternalListPool<T>.Rent();
+            self.GetComponentsInChildren_Internal(results, depth);
+            var array = results.ToArray();
+            InternalListPool<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();
+        }
+
+        /// <summary>
+        /// Add a component of a specific type to the children of a GameObject.
+        /// </summary>
+        public static void AddComponentOnChildren<T>(this Component self, bool includeSelf)
+            where T : Component
+        {
+            if (self == null) return;
+
+            Profiler.BeginSample("(COF)[ComponentExt] AddComponentOnChildren > Self");
+            if (includeSelf && !self.TryGetComponent<T>(out _))
+            {
+                self.gameObject.AddComponent<T>();
+            }
+
+            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;
+
+                child.gameObject.AddComponent<T>();
+            }
+
+            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 MonoImporter.GetAllRuntimeMonoScripts())
+            {
+                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/SpriteExtensions.cs

@@ -0,0 +1,60 @@
+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 Func<Sprite, Texture2D> s_GetActiveAtlasTextureMethod =
+            (Func<Sprite, Texture2D>)Delegate.CreateDelegate(typeof(Func<Sprite, Texture2D>),
+                s_SpriteEditorExtensionType
+                    .GetMethod("GetActiveAtlasTexture", BindingFlags.Static | BindingFlags.NonPublic));
+
+        private static readonly Func<Sprite, SpriteAtlas> s_GetActiveAtlasMethod =
+            (Func<Sprite, SpriteAtlas>)Delegate.CreateDelegate(typeof(Func<Sprite, SpriteAtlas>),
+                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;
+
+            var ret = s_GetActiveAtlasTextureMethod(self);
+            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(self);
+        }
+#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: 

Runtime/Internal/ProjectSettings.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 398e06c9985ad4291a95f0749c2927fb
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Internal/ProjectSettings/PreloadedProjectSettings.cs

@@ -0,0 +1,242 @@
+using System;
+using System.Linq;
+using UnityEngine;
+using Object = UnityEngine.Object;
+#if UNITY_EDITOR
+using System.IO;
+using UnityEditor;
+using UnityEditor.Build;
+using UnityEditor.Build.Reporting;
+#endif
+
+namespace Coffee.UIParticleInternal
+{
+    public abstract class PreloadedProjectSettings : ScriptableObject
+#if UNITY_EDITOR
+    {
+        private class Postprocessor : AssetPostprocessor
+        {
+            private static void OnPostprocessAllAssets(string[] _, string[] __, string[] ___, string[] ____)
+            {
+                Initialize();
+            }
+        }
+
+        private class PreprocessBuildWithReport : IPreprocessBuildWithReport
+        {
+            int IOrderedCallback.callbackOrder => 0;
+
+            void IPreprocessBuildWithReport.OnPreprocessBuild(BuildReport report)
+            {
+                Initialize();
+            }
+        }
+
+        private static void Initialize()
+        {
+            foreach (var t in TypeCache.GetTypesDerivedFrom(typeof(PreloadedProjectSettings<>)))
+            {
+                var defaultSettings = GetDefaultSettings(t);
+                if (!defaultSettings)
+                {
+                    // When create a new instance, automatically set it as default settings.
+                    defaultSettings = CreateInstance(t) as PreloadedProjectSettings;
+                    SetDefaultSettings(defaultSettings);
+                }
+                else if (GetPreloadedSettings(t).Length != 1)
+                {
+                    SetDefaultSettings(defaultSettings);
+                }
+
+                if (defaultSettings)
+                {
+                    defaultSettings.OnInitialize();
+                }
+            }
+        }
+
+        protected static string GetDefaultName(Type type, bool nicify)
+        {
+            var typeName = type.Name;
+            return nicify
+                ? ObjectNames.NicifyVariableName(typeName)
+                : typeName;
+        }
+
+        private static Object[] GetPreloadedSettings(Type type)
+        {
+            return PlayerSettings.GetPreloadedAssets()
+                .Where(x => x && x.GetType() == type)
+                .ToArray();
+        }
+
+        protected static PreloadedProjectSettings GetDefaultSettings(Type type)
+        {
+            return GetPreloadedSettings(type).FirstOrDefault() as PreloadedProjectSettings
+                   ?? AssetDatabase.FindAssets($"t:{nameof(PreloadedProjectSettings)}")
+                       .Select(AssetDatabase.GUIDToAssetPath)
+                       .Select(AssetDatabase.LoadAssetAtPath<PreloadedProjectSettings>)
+                       .FirstOrDefault(x => x && x.GetType() == type);
+        }
+
+        protected static void SetDefaultSettings(PreloadedProjectSettings asset)
+        {
+            if (!asset) return;
+
+            var type = asset.GetType();
+            if (string.IsNullOrEmpty(AssetDatabase.GetAssetPath(asset)))
+            {
+                if (!AssetDatabase.IsValidFolder("Assets/ProjectSettings"))
+                {
+                    AssetDatabase.CreateFolder("Assets", "ProjectSettings");
+                }
+
+                var assetPath = $"Assets/ProjectSettings/{GetDefaultName(type, false)}.asset";
+                assetPath = AssetDatabase.GenerateUniqueAssetPath(assetPath);
+                if (!File.Exists(assetPath))
+                {
+                    AssetDatabase.CreateAsset(asset, assetPath);
+                    asset.OnCreateAsset();
+                }
+            }
+
+            var preloadedAssets = PlayerSettings.GetPreloadedAssets();
+            var projectSettings = GetPreloadedSettings(type);
+            PlayerSettings.SetPreloadedAssets(preloadedAssets
+                .Where(x => x)
+                .Except(projectSettings.Except(new[] { asset }))
+                .Append(asset)
+                .Distinct()
+                .ToArray());
+
+            AssetDatabase.Refresh();
+        }
+
+        protected virtual void OnCreateAsset()
+        {
+        }
+
+        protected virtual void OnInitialize()
+        {
+        }
+    }
+#else
+    {
+    }
+#endif
+
+    public abstract class PreloadedProjectSettings<T> : PreloadedProjectSettings
+        where T : PreloadedProjectSettings<T>
+    {
+        private static T s_Instance;
+
+#if UNITY_EDITOR
+        private string _jsonText;
+
+        public static bool hasInstance => s_Instance;
+
+        public static T instance
+        {
+            get
+            {
+                if (s_Instance) return s_Instance;
+
+                s_Instance = GetDefaultSettings(typeof(T)) as T;
+                if (s_Instance) return s_Instance;
+
+                s_Instance = CreateInstance<T>();
+                if (!s_Instance)
+                {
+                    s_Instance = null;
+                    return s_Instance;
+                }
+
+                SetDefaultSettings(s_Instance);
+                return s_Instance;
+            }
+        }
+
+        private void OnPlayModeStateChanged(PlayModeStateChange state)
+        {
+            switch (state)
+            {
+                case PlayModeStateChange.ExitingEditMode:
+                    _jsonText = EditorJsonUtility.ToJson(this);
+                    break;
+                case PlayModeStateChange.ExitingPlayMode:
+                    if (_jsonText != null)
+                    {
+                        EditorJsonUtility.FromJsonOverwrite(_jsonText, this);
+                        _jsonText = null;
+                    }
+
+                    break;
+            }
+        }
+#else
+        public static T instance => s_Instance ? s_Instance : s_Instance = CreateInstance<T>();
+#endif
+
+        /// <summary>
+        /// This function is called when the object becomes enabled and active.
+        /// </summary>
+        protected virtual void OnEnable()
+        {
+#if UNITY_EDITOR
+            var isDefaultSettings = !s_Instance || s_Instance == this || GetDefaultSettings(typeof(T)) == this;
+            if (!isDefaultSettings)
+            {
+                DestroyImmediate(this, true);
+                return;
+            }
+
+            EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
+#endif
+
+            if (s_Instance) return;
+            s_Instance = this as T;
+        }
+
+        /// <summary>
+        /// This function is called when the behaviour becomes disabled.
+        /// </summary>
+        protected virtual void OnDisable()
+        {
+#if UNITY_EDITOR
+            EditorApplication.playModeStateChanged -= OnPlayModeStateChanged;
+#endif
+            if (s_Instance != this) return;
+
+            s_Instance = null;
+        }
+
+#if UNITY_EDITOR
+        protected sealed class PreloadedProjectSettingsProvider : SettingsProvider
+        {
+            private Editor _editor;
+            private PreloadedProjectSettings<T> _target;
+
+            public PreloadedProjectSettingsProvider(string path) : base(path, SettingsScope.Project)
+            {
+            }
+
+            public override void OnGUI(string searchContext)
+            {
+                if (!_target)
+                {
+                    if (_editor)
+                    {
+                        DestroyImmediate(_editor);
+                        _editor = null;
+                    }
+
+                    _target = instance;
+                    _editor = Editor.CreateEditor(_target);
+                }
+
+                _editor.OnInspectorGUI();
+            }
+        }
+#endif
+    }
+}

Runtime/Internal/ProjectSettings/PreloadedProjectSettings.cs.meta

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

Runtime/Internal/Utilities.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1b2877595f27c4a70a426991d515434f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Internal/Utilities/FastAction.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Profiling;
+
+namespace Coffee.UIParticleInternal
+{
+    /// <summary>
+    /// Base class for a fast action.
+    /// </summary>
+    internal class FastActionBase<T>
+    {
+        private static readonly InternalObjectPool<LinkedListNode<T>> s_NodePool =
+            new InternalObjectPool<LinkedListNode<T>>(() => new LinkedListNode<T>(default), _ => true,
+                x => x.Value = default);
+
+        private readonly LinkedList<T> _delegates = new LinkedList<T>();
+
+        /// <summary>
+        /// Adds a delegate to the action.
+        /// </summary>
+        public void Add(T rhs)
+        {
+            if (rhs == null) return;
+            Profiler.BeginSample("(COF)[FastAction] Add Action");
+            var node = s_NodePool.Rent();
+            node.Value = rhs;
+            _delegates.AddLast(node);
+            Profiler.EndSample();
+        }
+
+        /// <summary>
+        /// Removes a delegate from the action.
+        /// </summary>
+        public void Remove(T rhs)
+        {
+            if (rhs == null) return;
+            Profiler.BeginSample("(COF)[FastAction] Remove Action");
+            var node = _delegates.Find(rhs);
+            if (node != null)
+            {
+                _delegates.Remove(node);
+                s_NodePool.Return(ref node);
+            }
+
+            Profiler.EndSample();
+        }
+
+        /// <summary>
+        /// Invokes the action with a callback function.
+        /// </summary>
+        protected void Invoke(Action<T> callback)
+        {
+            var node = _delegates.First;
+            while (node != null)
+            {
+                try
+                {
+                    callback(node.Value);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e);
+                }
+
+                node = node.Next;
+            }
+        }
+
+        public void Clear()
+        {
+            _delegates.Clear();
+        }
+    }
+
+    /// <summary>
+    /// A fast action without parameters.
+    /// </summary>
+    internal class FastAction : FastActionBase<Action>
+    {
+        /// <summary>
+        /// Invoke all the registered delegates.
+        /// </summary>
+        public void Invoke()
+        {
+            Invoke(action => action.Invoke());
+        }
+    }
+}

Runtime/Internal/Utilities/FastAction.cs.meta

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

Runtime/Internal/Utilities/FrameCache.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Coffee.UIParticleInternal
+{
+    internal static class FrameCache
+    {
+        private static readonly Dictionary<Type, IFrameCache> s_Caches = new Dictionary<Type, IFrameCache>();
+
+        static FrameCache()
+        {
+            s_Caches.Clear();
+            UIExtraCallbacks.onLateAfterCanvasRebuild += ClearAllCache;
+        }
+
+#if UNITY_EDITOR
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+        private static void Clear()
+        {
+            s_Caches.Clear();
+        }
+#endif
+
+        /// <summary>
+        /// Tries to retrieve a value from the frame cache with a specified key.
+        /// </summary>
+        public static bool TryGet<T>(object key1, string key2, out T result)
+        {
+            return GetFrameCache<T>().TryGet((key1.GetHashCode(), key2.GetHashCode()), out result);
+        }
+
+        /// <summary>
+        /// Tries to retrieve a value from the frame cache with a specified key.
+        /// </summary>
+        public static bool TryGet<T>(object key1, string key2, int key3, out T result)
+        {
+            return GetFrameCache<T>().TryGet((key1.GetHashCode(), key2.GetHashCode() + key3), out result);
+        }
+
+        /// <summary>
+        /// Sets a value in the frame cache with a specified key.
+        /// </summary>
+        public static void Set<T>(object key1, string key2, T result)
+        {
+            GetFrameCache<T>().Set((key1.GetHashCode(), key2.GetHashCode()), result);
+        }
+
+        /// <summary>
+        /// Sets a value in the frame cache with a specified key.
+        /// </summary>
+        public static void Set<T>(object key1, string key2, int key3, T result)
+        {
+            GetFrameCache<T>().Set((key1.GetHashCode(), key2.GetHashCode() + key3), result);
+        }
+
+        private static void ClearAllCache()
+        {
+            foreach (var cache in s_Caches.Values)
+            {
+                cache.Clear();
+            }
+        }
+
+        private static FrameCacheContainer<T> GetFrameCache<T>()
+        {
+            var t = typeof(T);
+            if (s_Caches.TryGetValue(t, out var frameCache)) return frameCache as FrameCacheContainer<T>;
+
+            frameCache = new FrameCacheContainer<T>();
+            s_Caches.Add(t, frameCache);
+
+            return (FrameCacheContainer<T>)frameCache;
+        }
+
+        private interface IFrameCache
+        {
+            void Clear();
+        }
+
+        private class FrameCacheContainer<T> : IFrameCache
+        {
+            private readonly Dictionary<(int, int), T> _caches = new Dictionary<(int, int), T>();
+
+            public void Clear()
+            {
+                _caches.Clear();
+            }
+
+            public bool TryGet((int, int) key, out T result)
+            {
+                return _caches.TryGetValue(key, out result);
+            }
+
+            public void Set((int, int) key, T result)
+            {
+                _caches[key] = result;
+            }
+        }
+    }
+}

Runtime/Internal/Utilities/FrameCache.cs.meta

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

Runtime/Internal/Utilities/Logging.cs

@@ -0,0 +1,254 @@
+using System;
+using System.Text;
+using UnityEngine;
+using Object = UnityEngine.Object;
+#if ENABLE_COFFEE_LOGGER
+using System.Reflection;
+using System.Collections.Generic;
+#else
+using Conditional = System.Diagnostics.ConditionalAttribute;
+#endif
+
+namespace Coffee.UIParticleInternal
+{
+    internal static class Logging
+    {
+#if !ENABLE_COFFEE_LOGGER
+        private const string k_DisableSymbol = "DISABLE_COFFEE_LOGGER";
+
+        [Conditional(k_DisableSymbol)]
+#endif
+        private static void Log_Internal(LogType type, object tag, object message, Object context)
+        {
+#if ENABLE_COFFEE_LOGGER
+            AppendTag(s_Sb, tag);
+            s_Sb.Append(message);
+            switch (type)
+            {
+                case LogType.Error:
+                case LogType.Assert:
+                case LogType.Exception:
+                    Debug.LogError(s_Sb, context);
+                    break;
+                case LogType.Warning:
+                    Debug.LogWarning(s_Sb, context);
+                    break;
+                case LogType.Log:
+                    Debug.Log(s_Sb, context);
+                    break;
+            }
+
+            s_Sb.Length = 0;
+#endif
+        }
+
+#if !ENABLE_COFFEE_LOGGER
+        [Conditional(k_DisableSymbol)]
+#endif
+        public static void LogIf(bool enable, object tag, object message, Object context = null)
+        {
+            if (!enable) return;
+            Log_Internal(LogType.Log, tag, message, context ? context : tag as Object);
+        }
+
+#if !ENABLE_COFFEE_LOGGER
+        [Conditional(k_DisableSymbol)]
+#endif
+        public static void Log(object tag, object message, Object context = null)
+        {
+            Log_Internal(LogType.Log, tag, message, context ? context : tag as Object);
+        }
+
+#if !ENABLE_COFFEE_LOGGER
+        [Conditional(k_DisableSymbol)]
+#endif
+        public static void LogWarning(object tag, object message, Object context = null)
+        {
+            Log_Internal(LogType.Warning, tag, message, context ? context : tag as Object);
+        }
+
+        public static void LogError(object tag, object message, Object context = null)
+        {
+#if ENABLE_COFFEE_LOGGER
+            Log_Internal(LogType.Error, tag, message, context ? context : tag as Object);
+#else
+            Debug.LogError($"{tag}: {message}", context);
+#endif
+        }
+
+#if !ENABLE_COFFEE_LOGGER
+        [Conditional(k_DisableSymbol)]
+#endif
+        public static void LogMulticast(Type type, string fieldName, object instance = null, string message = null)
+        {
+#if ENABLE_COFFEE_LOGGER
+            AppendTag(s_Sb, instance ?? type);
+
+            var handler = type
+                .GetField(fieldName,
+                    BindingFlags.Static | BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic)
+                ?.GetValue(instance);
+
+            var list = ((MulticastDelegate)handler)?.GetInvocationList() ?? Array.Empty<Delegate>();
+            s_Sb.Append("<color=orange>");
+            s_Sb.Append(type.Name);
+            s_Sb.Append(".");
+            s_Sb.Append(fieldName);
+            s_Sb.Append(" has ");
+            s_Sb.Append(list.Length);
+            s_Sb.Append(" callbacks");
+            if (message != null)
+            {
+                s_Sb.Append(" (");
+                s_Sb.Append(message);
+                s_Sb.Append(")");
+            }
+
+            s_Sb.Append(":</color>");
+
+            for (var i = 0; i < list.Length; i++)
+            {
+                s_Sb.Append("\n - ");
+                s_Sb.Append(list[i].Method.DeclaringType?.Name);
+                s_Sb.Append(".");
+                s_Sb.Append(list[i].Method.Name);
+            }
+
+            Debug.Log(s_Sb);
+            s_Sb.Length = 0;
+#endif
+        }
+
+#if !ENABLE_COFFEE_LOGGER
+        [Conditional(k_DisableSymbol)]
+#endif
+        private static void AppendTag(StringBuilder sb, object tag)
+        {
+#if ENABLE_COFFEE_LOGGER
+            try
+            {
+                sb.Append("f");
+                sb.Append(Time.frameCount);
+                sb.Append(":<color=#");
+                AppendReadableCode(sb, tag);
+                sb.Append("><b>[");
+
+                switch (tag)
+                {
+                    case string name:
+                        sb.Append(name);
+                        break;
+                    case Type type:
+                        AppendType(sb, type);
+                        break;
+                    case Object uObject:
+                        AppendType(sb, tag.GetType());
+                        sb.Append(" #");
+                        sb.Append(uObject.name);
+                        break;
+                    default:
+                        AppendType(sb, tag.GetType());
+                        break;
+                }
+
+                sb.Append("]</b></color> ");
+            }
+            catch
+            {
+                sb.Append("f");
+                sb.Append(Time.frameCount);
+                sb.Append(":<b>[");
+                sb.Append(tag);
+                sb.Append("]</b> ");
+            }
+#endif
+        }
+
+#if !ENABLE_COFFEE_LOGGER
+        [Conditional(k_DisableSymbol)]
+#endif
+        private static void AppendType(StringBuilder sb, Type type)
+        {
+#if ENABLE_COFFEE_LOGGER
+            if (s_TypeNameCache.TryGetValue(type, out var name))
+            {
+                sb.Append(name);
+                return;
+            }
+
+            // New type found
+            var start = sb.Length;
+            if (0 < start && sb[start - 1] == '<' && (type.Name == "Material" || type.Name == "Color"))
+            {
+                sb.Append('@');
+            }
+
+            sb.Append(type.Name);
+            if (type.IsGenericType)
+            {
+                sb.Length -= 2;
+                sb.Append("<");
+                foreach (var gType in type.GetGenericArguments())
+                {
+                    AppendType(sb, gType);
+                    sb.Append(", ");
+                }
+
+                sb.Length -= 2;
+                sb.Append(">");
+            }
+
+            s_TypeNameCache.Add(type, sb.ToString(start, sb.Length - start));
+#endif
+        }
+
+#if !ENABLE_COFFEE_LOGGER
+        [Conditional(k_DisableSymbol)]
+#endif
+        private static void AppendReadableCode(StringBuilder sb, object tag)
+        {
+#if ENABLE_COFFEE_LOGGER
+            int hash;
+            try
+            {
+                switch (tag)
+                {
+                    case string text:
+                        hash = text.GetHashCode();
+                        break;
+                    case Type type:
+                        type = type.IsGenericType ? type.GetGenericTypeDefinition() : type;
+                        hash = type.FullName?.GetHashCode() ?? 0;
+                        break;
+                    default:
+                        hash = tag.GetType().FullName?.GetHashCode() ?? 0;
+                        break;
+                }
+            }
+            catch
+            {
+                sb.Append("FFFFFF");
+                return;
+            }
+
+            hash = hash & (s_Codes.Length - 1);
+            if (s_Codes[hash] == null)
+            {
+                var hue = hash / (float)s_Codes.Length;
+                var modifier = 1f - Mathf.Clamp01(Mathf.Abs(hue - 0.65f) / 0.2f);
+                var saturation = 0.7f + modifier * -0.2f;
+                var value = 0.8f + modifier * 0.3f;
+                s_Codes[hash] = ColorUtility.ToHtmlStringRGB(Color.HSVToRGB(hue, saturation, value));
+            }
+
+            sb.Append(s_Codes[hash]);
+#endif
+        }
+
+#if ENABLE_COFFEE_LOGGER
+        private static readonly StringBuilder s_Sb = new StringBuilder();
+        private static readonly string[] s_Codes = new string[64];
+        private static readonly Dictionary<Type, string> s_TypeNameCache = new Dictionary<Type, string>();
+#endif
+    }
+}

Runtime/Internal/Utilities/Logging.cs.meta

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

Runtime/Internal/Utilities/MaterialRepository.cs

@@ -0,0 +1,92 @@
+using System;
+using UnityEngine;
+using UnityEngine.Profiling;
+
+namespace Coffee.UIParticleInternal
+{
+    /// <summary>
+    /// Provides functionality to manage materials.
+    /// </summary>
+    internal static class MaterialRepository
+    {
+        private static readonly ObjectRepository<Material> s_Repository = new ObjectRepository<Material>();
+
+        public static int count => s_Repository.count;
+
+#if UNITY_EDITOR
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+        public static void Clear()
+        {
+            s_Repository.Clear();
+        }
+#endif
+
+        /// <summary>
+        /// Retrieves a cached material based on the hash.
+        /// </summary>
+        public static bool Valid(Hash128 hash, Material material)
+        {
+            Profiler.BeginSample("(COF)[MaterialRegistry] Valid");
+            var ret = s_Repository.Valid(hash, material);
+            Profiler.EndSample();
+            return ret;
+        }
+
+        /// <summary>
+        /// Adds or retrieves a cached material based on the hash.
+        /// </summary>
+        public static void Get(Hash128 hash, ref Material material, Func<Material> onCreate)
+        {
+            Profiler.BeginSample("(COF)[MaterialRepository] Get");
+            s_Repository.Get(hash, ref material, onCreate);
+            Profiler.EndSample();
+        }
+
+        /// <summary>
+        /// Adds or retrieves a cached material based on the hash.
+        /// </summary>
+        public static void Get(Hash128 hash, ref Material material, string shaderName)
+        {
+            Profiler.BeginSample("(COF)[MaterialRepository] Get");
+            s_Repository.Get(hash, ref material, x => new Material(Shader.Find(x))
+            {
+                hideFlags = HideFlags.DontSave | HideFlags.NotEditable
+            }, shaderName);
+            Profiler.EndSample();
+        }
+
+        /// <summary>
+        /// Adds or retrieves a cached material based on the hash.
+        /// </summary>
+        public static void Get(Hash128 hash, ref Material material, string shaderName, string[] keywords)
+        {
+            Profiler.BeginSample("(COF)[MaterialRepository] Get");
+            s_Repository.Get(hash, ref material, x => new Material(Shader.Find(x.shaderName))
+            {
+                hideFlags = HideFlags.DontSave | HideFlags.NotEditable,
+                shaderKeywords = x.keywords
+            }, (shaderName, keywords));
+            Profiler.EndSample();
+        }
+
+        /// <summary>
+        /// Adds or retrieves a cached material based on the hash.
+        /// </summary>
+        public static void Get<T>(Hash128 hash, ref Material material, Func<T, Material> onCreate, T source)
+        {
+            Profiler.BeginSample("(COF)[MaterialRepository] Get");
+            s_Repository.Get(hash, ref material, onCreate, source);
+            Profiler.EndSample();
+        }
+
+        /// <summary>
+        /// Removes a soft mask material from the cache.
+        /// </summary>
+        public static void Release(ref Material material)
+        {
+            Profiler.BeginSample("(COF)[MaterialRepository] Release");
+            s_Repository.Release(ref material);
+            Profiler.EndSample();
+        }
+    }
+}

Runtime/Internal/Utilities/MaterialRepository.cs.meta

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

Runtime/Internal/Utilities/Misc.cs

@@ -0,0 +1,132 @@
+using System;
+using System.Diagnostics;
+using UnityEditor;
+using UnityEngine;
+using Object = UnityEngine.Object;
+#if UNITY_EDITOR
+using System.IO;
+using System.Linq;
+using System.Reflection;
+#if UNITY_2021_2_OR_NEWER
+using UnityEditor.SceneManagement;
+#else
+using UnityEditor.Experimental.SceneManagement;
+#endif
+#endif
+
+namespace Coffee.UIParticleInternal
+{
+    internal static class Misc
+    {
+        public static T[] FindObjectsOfType<T>() where T : Object
+        {
+#if UNITY_2023_1_OR_NEWER
+            return Object.FindObjectsByType<T>(FindObjectsInactive.Include, FindObjectsSortMode.None);
+#else
+            return Object.FindObjectsOfType<T>();
+#endif
+        }
+
+        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
+        }
+
+#if UNITY_EDITOR
+        public static T[] GetAllComponentsInPrefabStage<T>() where T : Component
+        {
+            var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
+            if (prefabStage == null) return Array.Empty<T>();
+
+            return prefabStage.prefabContentsRoot.GetComponentsInChildren<T>(true);
+        }
+
+        public static bool isBatchOrBuilding => Application.isBatchMode || BuildPipeline.isBuildingPlayer;
+#endif
+
+        [Conditional("UNITY_EDITOR")]
+        public static void QueuePlayerLoopUpdate()
+        {
+#if UNITY_EDITOR
+            if (!EditorApplication.isPlaying)
+            {
+                EditorApplication.QueuePlayerLoopUpdate();
+            }
+#endif
+        }
+    }
+
+#if !UNITY_2021_2_OR_NEWER
+    [AttributeUsage(AttributeTargets.Class)]
+    [Conditional("UNITY_EDITOR")]
+    internal class IconAttribute : Attribute
+    {
+        private readonly string _path;
+
+        public IconAttribute(string path)
+        {
+            _path = path;
+        }
+
+#if UNITY_EDITOR
+        private static Action<Object, Texture2D> s_SetIconForObject = typeof(EditorGUIUtility)
+            .GetMethod("SetIconForObject", BindingFlags.Static | BindingFlags.NonPublic)
+            .CreateDelegate(typeof(Action<Object, Texture2D>), null) as Action<Object, Texture2D>;
+
+        [InitializeOnLoadMethod]
+        private static void InitializeOnLoadMethod()
+        {
+            if (Misc.isBatchOrBuilding) return;
+
+            var types = TypeCache.GetTypesWithAttribute<IconAttribute>();
+            var scripts = MonoImporter.GetAllRuntimeMonoScripts();
+            foreach (var type in types)
+            {
+                var script = scripts.FirstOrDefault(x => x.GetClass() == type);
+                if (!script) continue;
+
+                var path = type.GetCustomAttribute<IconAttribute>()?._path;
+                var icon = AssetDatabase.LoadAssetAtPath<Texture2D>(path);
+                if (!icon) continue;
+
+                s_SetIconForObject(script, icon);
+            }
+        }
+#endif
+    }
+#endif
+}

Runtime/Internal/Utilities/Misc.cs.meta

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

Runtime/Internal/Utilities/ObjectPool.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Collections.Generic;
+
+namespace Coffee.UIParticleInternal
+{
+    /// <summary>
+    /// Object pool.
+    /// </summary>
+    internal class InternalObjectPool<T> where T : class
+    {
+#if UNITY_2021_1_OR_NEWER
+        private readonly Predicate<T> _onValid; // Delegate for checking if instances are valid
+        private readonly UnityEngine.Pool.ObjectPool<T> _pool;
+
+        public InternalObjectPool(Func<T> onCreate, Predicate<T> onValid, Action<T> onReturn)
+        {
+            _pool = new UnityEngine.Pool.ObjectPool<T>(onCreate, null, onReturn);
+            _onValid = onValid;
+        }
+
+        /// <summary>
+        /// Rent an instance from the pool.
+        /// When you no longer need it, return it with <see cref="Return" />.
+        /// </summary>
+        public T Rent()
+        {
+            while (0 < _pool.CountInactive)
+            {
+                var instance = _pool.Get();
+                if (_onValid(instance))
+                {
+                    return instance;
+                }
+            }
+
+            // If there are no instances in the pool, create a new one.
+            Logging.Log(this, $"A new instance is created (pooled: {_pool.CountInactive}, created: {_pool.CountAll}).");
+            return _pool.Get();
+        }
+
+        /// <summary>
+        /// Return an instance to the pool and assign null.
+        /// Be sure to return the instance obtained with <see cref="Rent" /> with this method.
+        /// </summary>
+        public void Return(ref T instance)
+        {
+            if (instance == null) return; // Ignore if already pooled or null.
+
+            _pool.Release(instance);
+            Logging.Log(this, $"An instance is released (pooled: {_pool.CountInactive}, created: {_pool.CountAll}).");
+            instance = default; // Set the reference to null.
+        }
+#else
+        private readonly Func<T> _onCreate; // Delegate for creating instances
+        private readonly Action<T> _onReturn; // Delegate for returning instances to the pool
+        private readonly Predicate<T> _onValid; // Delegate for checking if instances are valid
+        private readonly Stack<T> _pool = new Stack<T>(32); // Object pool
+        private int _count; // Total count of created instances
+
+        public InternalObjectPool(Func<T> onCreate, Predicate<T> onValid, Action<T> onReturn)
+        {
+            _onCreate = onCreate;
+            _onValid = onValid;
+            _onReturn = onReturn;
+        }
+
+        /// <summary>
+        /// Rent an instance from the pool.
+        /// When you no longer need it, return it with <see cref="Return" />.
+        /// </summary>
+        public T Rent()
+        {
+            while (0 < _pool.Count)
+            {
+                var instance = _pool.Pop();
+                if (_onValid(instance))
+                {
+                    return instance;
+                }
+            }
+
+            // If there are no instances in the pool, create a new one.
+            Logging.Log(this, $"A new instance is created (pooled: {_pool.Count}, created: {++_count}).");
+            return _onCreate();
+        }
+
+        /// <summary>
+        /// Return an instance to the pool and assign null.
+        /// Be sure to return the instance obtained with <see cref="Rent" /> with this method.
+        /// </summary>
+        public void Return(ref T instance)
+        {
+            if (instance == null || _pool.Contains(instance)) return; // Ignore if already pooled or null.
+
+            _onReturn(instance); // Return the instance to the pool.
+            _pool.Push(instance);
+            Logging.Log(this, $"An instance is released (pooled: {_pool.Count}, created: {_count}).");
+            instance = default; // Set the reference to null.
+        }
+#endif
+    }
+
+    /// <summary>
+    /// Object pool for <see cref="List{T}" />.
+    /// </summary>
+    internal static class InternalListPool<T>
+    {
+#if UNITY_2021_1_OR_NEWER
+        /// <summary>
+        /// Rent an instance from the pool.
+        /// When you no longer need it, return it with <see cref="Return" />.
+        /// </summary>
+        public static List<T> Rent()
+        {
+            return UnityEngine.Pool.ListPool<T>.Get();
+        }
+
+        /// <summary>
+        /// Return an instance to the pool and assign null.
+        /// Be sure to return the instance obtained with <see cref="Rent" /> with this method.
+        /// </summary>
+        public static void Return(ref List<T> toRelease)
+        {
+            if (toRelease != null)
+            {
+                UnityEngine.Pool.ListPool<T>.Release(toRelease);
+            }
+
+            toRelease = null;
+        }
+#else
+        private static readonly InternalObjectPool<List<T>> s_ListPool =
+            new InternalObjectPool<List<T>>(() => new List<T>(), _ => true, x => x.Clear());
+
+        /// <summary>
+        /// Rent an instance from the pool.
+        /// When you no longer need it, return it with <see cref="Return" />.
+        /// </summary>
+        public static List<T> Rent()
+        {
+            return s_ListPool.Rent();
+        }
+
+        /// <summary>
+        /// Return an instance to the pool and assign null.
+        /// Be sure to return the instance obtained with <see cref="Rent" /> with this method.
+        /// </summary>
+        public static void Return(ref List<T> toRelease)
+        {
+            s_ListPool.Return(ref toRelease);
+        }
+#endif
+    }
+}

Runtime/Internal/Utilities/ObjectPool.cs.meta

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

Runtime/Internal/Utilities/ObjectRepository.cs

@@ -0,0 +1,209 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Profiling;
+using Object = UnityEngine.Object;
+
+namespace Coffee.UIParticleInternal
+{
+    internal class ObjectRepository<T> where T : Object
+    {
+        private readonly Dictionary<Hash128, Entry> _cache = new Dictionary<Hash128, Entry>(8);
+        private readonly Dictionary<int, Hash128> _objectKey = new Dictionary<int, Hash128>(8);
+        private readonly string _name;
+        private readonly Action<T> _onRelease;
+        private readonly Stack<Entry> _pool = new Stack<Entry>(8);
+
+        public ObjectRepository(Action<T> onRelease = null)
+        {
+            _name = $"{typeof(T).Name}Repository";
+            if (onRelease == null)
+            {
+                _onRelease = x =>
+                {
+#if UNITY_EDITOR
+                    if (!Application.isPlaying)
+                    {
+                        Object.DestroyImmediate(x, false);
+                    }
+                    else
+#endif
+                    {
+                        Object.Destroy(x);
+                    }
+                };
+            }
+            else
+            {
+                _onRelease = onRelease;
+            }
+
+            for (var i = 0; i < 8; i++)
+            {
+                _pool.Push(new Entry());
+            }
+        }
+
+        public int count => _cache.Count;
+
+        public void Clear()
+        {
+            foreach (var kv in _cache)
+            {
+                var entry = kv.Value;
+                if (entry == null) continue;
+
+                entry.Release(_onRelease);
+                _pool.Push(entry);
+            }
+
+            _cache.Clear();
+            _objectKey.Clear();
+        }
+
+        public bool Valid(Hash128 hash, T obj)
+        {
+            return _cache.TryGetValue(hash, out var entry) && entry.storedObject == obj;
+        }
+
+        /// <summary>
+        /// Adds or retrieves a cached object based on the hash.
+        /// </summary>
+        public void Get(Hash128 hash, ref T obj, Func<T> onCreate)
+        {
+            if (GetFromCache(hash, ref obj)) return;
+            Add(hash, ref obj, onCreate());
+        }
+
+        /// <summary>
+        /// Adds or retrieves a cached object based on the hash.
+        /// </summary>
+        public void Get<TS>(Hash128 hash, ref T obj, Func<TS, T> onCreate, TS source)
+        {
+            if (GetFromCache(hash, ref obj)) return;
+            Add(hash, ref obj, onCreate(source));
+        }
+
+        private bool GetFromCache(Hash128 hash, ref T obj)
+        {
+            // Find existing entry.
+            Profiler.BeginSample("(COF)[ObjectRepository] GetFromCache");
+            if (_cache.TryGetValue(hash, out var entry))
+            {
+                if (!entry.storedObject)
+                {
+                    Release(ref entry.storedObject);
+                    Profiler.EndSample();
+                    return false;
+                }
+
+                if (entry.storedObject != obj)
+                {
+                    // if the object is different, release the old one.
+                    Release(ref obj);
+                    ++entry.reference;
+                    obj = entry.storedObject;
+                    Logging.Log(_name, $"Get(total#{count}): {entry}");
+                }
+
+                Profiler.EndSample();
+                return true;
+            }
+
+            Profiler.EndSample();
+            return false;
+        }
+
+        private void Add(Hash128 hash, ref T obj, T newObject)
+        {
+            if (!newObject)
+            {
+                Release(ref obj);
+                obj = newObject;
+                return;
+            }
+
+            // Create and add a new entry.
+            Profiler.BeginSample("(COF)[ObjectRepository] Add");
+            var newEntry = 0 < _pool.Count ? _pool.Pop() : new Entry();
+            newEntry.storedObject = newObject;
+            newEntry.hash = hash;
+            newEntry.reference = 1;
+            _cache[hash] = newEntry;
+            _objectKey[newObject.GetInstanceID()] = hash;
+            Logging.Log(_name, $"<color=#03c700>Add</color>(total#{count}): {newEntry}");
+            Release(ref obj);
+            obj = newObject;
+            Profiler.EndSample();
+        }
+
+        /// <summary>
+        /// Release a object.
+        /// </summary>
+        public void Release(ref T obj)
+        {
+            if (ReferenceEquals(obj, null)) return;
+
+            // Find and release the entry.
+            Profiler.BeginSample("(COF)[ObjectRepository] Release");
+            var id = obj.GetInstanceID();
+            if (_objectKey.TryGetValue(id, out var hash)
+                && _cache.TryGetValue(hash, out var entry))
+            {
+                entry.reference--;
+                if (entry.reference <= 0 || !entry.storedObject)
+                {
+                    Remove(entry);
+                }
+                else
+                {
+                    Logging.Log(_name, $"Release(total#{_cache.Count}): {entry}");
+                }
+            }
+            else
+            {
+                Logging.Log(_name, $"Release(total#{_cache.Count}): <color=red>Already released: {obj}</color>");
+            }
+
+            obj = null;
+            Profiler.EndSample();
+        }
+
+        private void Remove(Entry entry)
+        {
+            if (ReferenceEquals(entry, null)) return;
+
+            Profiler.BeginSample("(COF)[ObjectRepository] Remove");
+            _cache.Remove(entry.hash);
+            _objectKey.Remove(entry.storedObject.GetInstanceID());
+            _pool.Push(entry);
+            entry.reference = 0;
+            Logging.Log(_name, $"<color=#f29e03>Remove</color>(total#{_cache.Count}): {entry}");
+            entry.Release(_onRelease);
+            Profiler.EndSample();
+        }
+
+        private class Entry
+        {
+            public Hash128 hash;
+            public int reference;
+            public T storedObject;
+
+            public void Release(Action<T> onRelease)
+            {
+                reference = 0;
+                if (storedObject)
+                {
+                    onRelease?.Invoke(storedObject);
+                }
+
+                storedObject = null;
+            }
+
+            public override string ToString()
+            {
+                return $"h{(uint)hash.GetHashCode()} (refs#{reference}), {storedObject}";
+            }
+        }
+    }
+}

Runtime/Internal/Utilities/ObjectRepository.cs.meta

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

Runtime/Internal/Utilities/UIExtraCallbacks.cs

@@ -0,0 +1,115 @@
+using System;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Coffee.UIParticleInternal
+{
+    /// <summary>
+    /// Provides additional callbacks related to canvas and UI system.
+    /// </summary>
+    internal static class UIExtraCallbacks
+    {
+        private static bool s_IsInitializedAfterCanvasRebuild;
+        private static readonly FastAction s_AfterCanvasRebuildAction = new FastAction();
+        private static readonly FastAction s_LateAfterCanvasRebuildAction = new FastAction();
+        private static readonly FastAction s_BeforeCanvasRebuildAction = new FastAction();
+        private static readonly FastAction s_OnScreenSizeChangedAction = new FastAction();
+        private static Vector2Int s_LastScreenSize;
+
+        static UIExtraCallbacks()
+        {
+            Canvas.willRenderCanvases += OnBeforeCanvasRebuild;
+            Logging.LogMulticast(typeof(Canvas), "willRenderCanvases", message: "ctor");
+        }
+
+        /// <summary>
+        /// Event that occurs after canvas rebuilds.
+        /// </summary>
+        public static event Action onLateAfterCanvasRebuild
+        {
+            add => s_LateAfterCanvasRebuildAction.Add(value);
+            remove => s_LateAfterCanvasRebuildAction.Remove(value);
+        }
+
+        /// <summary>
+        /// Event that occurs before canvas rebuilds.
+        /// </summary>
+        public static event Action onBeforeCanvasRebuild
+        {
+            add => s_BeforeCanvasRebuildAction.Add(value);
+            remove => s_BeforeCanvasRebuildAction.Remove(value);
+        }
+
+        /// <summary>
+        /// Event that occurs after canvas rebuilds.
+        /// </summary>
+        public static event Action onAfterCanvasRebuild
+        {
+            add => s_AfterCanvasRebuildAction.Add(value);
+            remove => s_AfterCanvasRebuildAction.Remove(value);
+        }
+
+        /// <summary>
+        /// Event that occurs when the screen size changes.
+        /// </summary>
+        public static event Action onScreenSizeChanged
+        {
+            add => s_OnScreenSizeChangedAction.Add(value);
+            remove => s_OnScreenSizeChangedAction.Remove(value);
+        }
+
+        /// <summary>
+        /// Initializes the UIExtraCallbacks to ensure proper event handling.
+        /// </summary>
+        private static void InitializeAfterCanvasRebuild()
+        {
+            if (s_IsInitializedAfterCanvasRebuild) return;
+            s_IsInitializedAfterCanvasRebuild = true;
+
+            CanvasUpdateRegistry.IsRebuildingLayout();
+            Canvas.willRenderCanvases += OnAfterCanvasRebuild;
+            Logging.LogMulticast(typeof(Canvas), "willRenderCanvases",
+                message: "InitializeAfterCanvasRebuild");
+        }
+
+#if UNITY_EDITOR
+        [InitializeOnLoadMethod]
+#endif
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        private static void InitializeOnLoad()
+        {
+            Canvas.willRenderCanvases -= OnAfterCanvasRebuild;
+            s_IsInitializedAfterCanvasRebuild = false;
+        }
+
+        /// <summary>
+        /// Callback method called before canvas rebuilds.
+        /// </summary>
+        private static void OnBeforeCanvasRebuild()
+        {
+            var screenSize = new Vector2Int(Screen.width, Screen.height);
+            if (s_LastScreenSize != screenSize)
+            {
+                if (s_LastScreenSize != default)
+                {
+                    s_OnScreenSizeChangedAction.Invoke();
+                }
+
+                s_LastScreenSize = screenSize;
+            }
+
+            s_BeforeCanvasRebuildAction.Invoke();
+            InitializeAfterCanvasRebuild();
+        }
+
+        /// <summary>
+        /// Callback method called after canvas rebuilds.
+        /// </summary>
+        private static void OnAfterCanvasRebuild()
+        {
+            s_AfterCanvasRebuildAction.Invoke();
+            s_LateAfterCanvasRebuildAction.Invoke();
+        }
+    }
+}

Runtime/Internal/Utilities/UIExtraCallbacks.cs.meta

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

Runtime/ModifiedMaterial.cs

@@ -1,72 +0,0 @@
-using System.Collections.Generic;
-using UnityEngine;
-
-namespace Coffee.UIParticleExtensions
-{
-    internal class ModifiedMaterial
-    {
-        private static readonly List<MatEntry> s_Entries = new List<MatEntry>();
-
-        public static Material Add(Material baseMat, Texture texture, int id, int props)
-        {
-            MatEntry e;
-            for (var i = 0; i < s_Entries.Count; i++)
-            {
-                e = s_Entries[i];
-                if (e.baseMat != baseMat || e.texture != texture || e.id != id || e.props != props) continue;
-                ++e.count;
-                return e.customMat;
-            }
-
-            e = new MatEntry
-            {
-                count = 1,
-                baseMat = baseMat,
-                texture = texture,
-                id = id,
-                props = props,
-                customMat = new Material(baseMat)
-                {
-                    name = $"{baseMat.name}_{id}",
-                    hideFlags = HideFlags.DontSave | HideFlags.NotEditable,
-                    mainTexture = texture ? texture : baseMat.mainTexture
-                }
-            };
-            s_Entries.Add(e);
-            //Debug.LogFormat(">>>> ModifiedMaterial.Add -> count = count:{0}, mat:{1}, tex:{2}, id:{3}", s_Entries.Count, baseMat, texture, id);
-            return e.customMat;
-        }
-
-        public static void Remove(Material customMat)
-        {
-            if (!customMat) return;
-
-            for (var i = 0; i < s_Entries.Count; ++i)
-            {
-                var e = s_Entries[i];
-                if (e.customMat != customMat) continue;
-                if (--e.count == 0)
-                {
-                    //Debug.LogFormat(">>>> ModifiedMaterial.Remove -> count:{0}, mat:{1}, tex:{2}, id:{3}", s_Entries.Count - 1, e.customMat, e.texture, e.id);
-                    Misc.DestroyImmediate(e.customMat);
-                    e.customMat = null;
-                    e.baseMat = null;
-                    e.texture = null;
-                    s_Entries.RemoveAt(i);
-                }
-
-                break;
-            }
-        }
-
-        private class MatEntry
-        {
-            public Material baseMat;
-            public int count;
-            public Material customMat;
-            public int id;
-            public int props;
-            public Texture texture;
-        }
-    }
-}

Runtime/UIParticle.cs

@@ -1,8 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
-using Coffee.UIParticleExtensions;
-using UnityEditor;
+using Coffee.UIParticleInternal;
 using UnityEngine;
 using UnityEngine.Rendering;
 using UnityEngine.Serialization;
@@ -10,12 +9,15 @@ using UnityEngine.UI;
 using Random = UnityEngine.Random;
 
 [assembly: InternalsVisibleTo("Coffee.UIParticle.Editor")]
+[assembly: InternalsVisibleTo("Coffee.UIParticle.PerformanceDemo")]
+[assembly: InternalsVisibleTo("Coffee.UIParticle.Demo")]
 
 namespace Coffee.UIExtensions
 {
     /// <summary>
     /// Render maskable and sortable particle effect ,without Camera, RenderTexture or Canvas.
     /// </summary>
+    [Icon("Packages/com.coffee.ui-particle/Icons/UIParticleIcon.png")]
     [ExecuteAlways]
     [RequireComponent(typeof(RectTransform))]
     [RequireComponent(typeof(CanvasRenderer))]
@@ -45,23 +47,26 @@ namespace Coffee.UIExtensions
 
         [HideInInspector]
         [SerializeField]
+        [Obsolete]
         internal bool m_IsTrail;
 
         [HideInInspector]
         [FormerlySerializedAs("m_IgnoreParent")]
         [SerializeField]
+        [Obsolete]
         private bool m_IgnoreCanvasScaler;
 
         [HideInInspector]
         [SerializeField]
-        private bool m_AbsoluteMode;
+        [Obsolete]
+        internal bool m_AbsoluteMode;
 
-        [Tooltip("Particle effect scale")]
+        [Tooltip("Scale the rendering particles. When the `3D` toggle is enabled, 3D scale (x, y, z) is supported.")]
         [SerializeField]
         private Vector3 m_Scale3D = new Vector3(10, 10, 10);
 
-        [Tooltip("Animatable material properties.\n" +
-                 "If you want to change the material properties of the ParticleSystem in Animation, enable it.")]
+        [Tooltip("If you want to update material properties (e.g. _MainTex_ST, _Color) in AnimationClip, " +
+                 "use this to mark as animatable.")]
         [SerializeField]
         internal AnimatableProperty[] m_AnimatableProperties = new AnimatableProperty[0];
 
@@ -69,12 +74,13 @@ namespace Coffee.UIExtensions
         [SerializeField]
         private List<ParticleSystem> m_Particles = new List<ParticleSystem>();
 
-        [Tooltip("Mesh sharing.\n" +
-                 "None: disable mesh sharing.\n" +
-                 "Auto: automatically select Primary/Replica.\n" +
-                 "Primary: provides particle simulation results to the same group.\n" +
+        [Tooltip("Particle simulation results are shared within the same group. " +
+                 "A large number of the same effects can be displayed with a small load.\n" +
+                 "None: Disable mesh sharing.\n" +
+                 "Auto: Automatically select Primary/Replica.\n" +
+                 "Primary: Provides particle simulation results to the same group.\n" +
                  "Primary Simulator: Primary, but do not render the particle (simulation only).\n" +
-                 "Replica: render simulation results provided by the primary.")]
+                 "Replica: Render simulation results provided by the primary.")]
         [SerializeField]
         private MeshSharing m_MeshSharing = MeshSharing.None;
 
@@ -86,23 +92,43 @@ namespace Coffee.UIExtensions
         [SerializeField]
         private int m_GroupMaxId;
 
-        [Tooltip("Relative: The particles will be emitted from the scaled position of ParticleSystem.\n" +
-                 "Absolute: The particles will be emitted from the world position of ParticleSystem.")]
+        [Tooltip("Emission position mode.\n" +
+                 "Relative: The particles will be emitted from the scaled position.\n" +
+                 "Absolute: The particles will be emitted from the world position.")]
         [SerializeField]
         private PositionMode m_PositionMode = PositionMode.Relative;
 
         [SerializeField]
-        [Tooltip("Prevent the root-Canvas scale from affecting the hierarchy-scaled ParticleSystem.")]
-        private bool m_AutoScaling = true;
+        [Obsolete]
+        internal bool m_AutoScaling;
 
         [SerializeField]
-        [Tooltip("Transform: Transform.lossyScale (=world scale) will be set to (1, 1, 1)." +
-                 "UIParticle: UIParticle.scale will be adjusted.")]
+        [Tooltip(
+            "How to automatically adjust when the Canvas scale is changed by the screen size or reference resolution.\n" +
+            "None: Do nothing.\n" +
+            "Transform: Transform.lossyScale (=world scale) will be set to (1, 1, 1).\n" +
+            "UIParticle: UIParticle.scale will be adjusted.")]
         private AutoScalingMode m_AutoScalingMode = AutoScalingMode.Transform;
 
+        [SerializeField]
+        [Tooltip("Use a custom view.\n" +
+                 "Use this if the particles are not displayed correctly due to min/max particle size.")]
+        private bool m_UseCustomView;
+
+        [SerializeField]
+        [Tooltip("Custom view size.\n" +
+                 "Change the bake view size.")]
+        private float m_CustomViewSize = 10;
+
+        [SerializeField]
+        [Tooltip("Time scale multiplier.")]
+        private float m_TimeScaleMultiplier = 1;
+
         private readonly List<UIParticleRenderer> _renderers = new List<UIParticleRenderer>();
+        private Camera _bakeCamera;
         private int _groupId;
-        private Camera _orthoCamera;
+        private bool _isScaleStored;
+        private Vector3 _storedScale;
         private DrivenRectTransformTracker _tracker;
 
         /// <summary>
@@ -115,7 +141,8 @@ namespace Coffee.UIExtensions
         }
 
         /// <summary>
-        /// Mesh sharing.
+        /// Particle simulation results are shared within the same group.
+        /// A large number of the same effects can be displayed with a small load.
         /// None: disable mesh sharing.
         /// Auto: automatically select Primary/Replica.
         /// Primary: provides particle simulation results to the same group.
@@ -158,9 +185,9 @@ namespace Coffee.UIExtensions
         }
 
         /// <summary>
-        /// Particle position mode.
-        /// Relative: The particles will be emitted from the scaled position of the ParticleSystem.
-        /// Absolute: The particles will be emitted from the world position of the ParticleSystem.
+        /// Emission position mode.
+        /// Relative: The particles will be emitted from the scaled position.
+        /// Absolute: The particles will be emitted from the world position.
         /// </summary>
         public PositionMode positionMode
         {
@@ -173,6 +200,7 @@ namespace Coffee.UIExtensions
         /// Relative: The particles will be emitted from the scaled position of the ParticleSystem.
         /// Absolute: The particles will be emitted from the world position of the ParticleSystem.
         /// </summary>
+        [Obsolete("The absoluteMode is now obsolete. Please use the autoScalingMode instead.", false)]
         public bool absoluteMode
         {
             get => m_PositionMode == PositionMode.Absolute;
@@ -190,8 +218,12 @@ namespace Coffee.UIExtensions
         }
 
         /// <summary>
-        /// Auto scaling mode.
+        /// How to automatically adjust when the Canvas scale is changed by the screen size or reference resolution.
+        /// <para/>
+        /// None: Do nothing.
+        /// <para/>
         /// Transform: Transform.lossyScale (=world scale) will be set to (1, 1, 1).
+        /// <para/>
         /// UIParticle: UIParticle.scale will be adjusted.
         /// </summary>
         public AutoScalingMode autoScalingMode
@@ -201,10 +233,44 @@ namespace Coffee.UIExtensions
             {
                 if (m_AutoScalingMode == value) return;
                 m_AutoScalingMode = value;
-                UpdateTracker();
+
+                if (autoScalingMode != AutoScalingMode.Transform && _isScaleStored)
+                {
+                    transform.localScale = _storedScale;
+                    _isScaleStored = false;
+                }
             }
         }
 
+        /// <summary>
+        /// Use a custom view.
+        /// Use this if the particles are not displayed correctly due to min/max particle size.
+        /// </summary>
+        public bool useCustomView
+        {
+            get => m_UseCustomView;
+            set => m_UseCustomView = value;
+        }
+
+        /// <summary>
+        /// Custom view size.
+        /// Change the bake view size.
+        /// </summary>
+        public float customViewSize
+        {
+            get => m_CustomViewSize;
+            set => m_CustomViewSize = Mathf.Max(0.1f, value);
+        }
+
+        /// <summary>
+        /// Time scale multiplier.
+        /// </summary>
+        public float timeScaleMultiplier
+        {
+            get => m_TimeScaleMultiplier;
+            set => m_TimeScaleMultiplier = value;
+        }
+
         internal bool useMeshSharing => m_MeshSharing != MeshSharing.None;
 
         internal bool isPrimary =>
@@ -244,30 +310,12 @@ namespace Coffee.UIExtensions
         /// <summary>
         /// Particle effect scale.
         /// </summary>
-        public Vector3 scale3DForCalc => autoScalingMode == AutoScalingMode.UIParticle
-            ? m_Scale3D.GetScaled(canvasScale)
-            : m_Scale3D;
+        public Vector3 scale3DForCalc => autoScalingMode == AutoScalingMode.Transform
+            ? m_Scale3D
+            : m_Scale3D.GetScaled(canvasScale, transform.localScale);
 
         public List<ParticleSystem> particles => m_Particles;
 
-        /// <summary>
-        /// Get all base materials to render.
-        /// </summary>
-        public IEnumerable<Material> materials
-        {
-            get
-            {
-                for (var i = 0; i < _renderers.Count; i++)
-                {
-                    var r = _renderers[i];
-                    if (!r || !r.material) continue;
-                    yield return r.material;
-                }
-            }
-        }
-
-        public override Material materialForRendering => null;
-
         /// <summary>
         /// Paused.
         /// </summary>
@@ -279,8 +327,8 @@ namespace Coffee.UIExtensions
 
         protected override void OnEnable()
         {
+            _isScaleStored = false;
             ResetGroupId();
-            UpdateTracker();
             UIParticleUpdater.Register(this);
             RegisterDirtyMaterialCallback(UpdateRendererMaterial);
 
@@ -301,7 +349,13 @@ namespace Coffee.UIExtensions
         /// </summary>
         protected override void OnDisable()
         {
-            UpdateTracker();
+            _tracker.Clear();
+            if (autoScalingMode == AutoScalingMode.Transform && _isScaleStored)
+            {
+                transform.localScale = _storedScale;
+            }
+
+            _isScaleStored = false;
             UIParticleUpdater.Unregister(this);
             _renderers.ForEach(r => r.Reset());
             UnregisterDirtyMaterialCallback(UpdateRendererMaterial);
@@ -316,20 +370,13 @@ namespace Coffee.UIExtensions
         {
         }
 
-#if UNITY_EDITOR
-        protected override void OnValidate()
-        {
-            base.OnValidate();
-            UpdateTracker();
-        }
-#endif
-
         void ISerializationCallbackReceiver.OnBeforeSerialize()
         {
         }
 
         void ISerializationCallbackReceiver.OnAfterDeserialize()
         {
+#pragma warning disable CS0612 // Type or member is obsolete
             if (m_IgnoreCanvasScaler || m_AutoScaling)
             {
                 m_IgnoreCanvasScaler = false;
@@ -342,31 +389,47 @@ namespace Coffee.UIExtensions
                 m_AbsoluteMode = false;
                 m_PositionMode = PositionMode.Absolute;
             }
+#pragma warning restore CS0612 // Type or member is obsolete
         }
 
+        /// <summary>
+        /// Play the ParticleSystems.
+        /// </summary>
         public void Play()
         {
             particles.Exec(p => p.Simulate(0, false, true));
             isPaused = false;
         }
 
+        /// <summary>
+        /// Pause the ParticleSystems.
+        /// </summary>
         public void Pause()
         {
             particles.Exec(p => p.Pause());
             isPaused = true;
         }
 
+        /// <summary>
+        /// Unpause the ParticleSystems.
+        /// </summary>
         public void Resume()
         {
             isPaused = false;
         }
 
+        /// <summary>
+        /// Stop the ParticleSystems.
+        /// </summary>
         public void Stop()
         {
             particles.Exec(p => p.Stop());
             isPaused = true;
         }
 
+        /// <summary>
+        /// Start emission of the ParticleSystems.
+        /// </summary>
         public void StartEmission()
         {
             particles.Exec(p =>
@@ -376,6 +439,9 @@ namespace Coffee.UIExtensions
             });
         }
 
+        /// <summary>
+        /// Stop emission of the ParticleSystems.
+        /// </summary>
         public void StopEmission()
         {
             particles.Exec(p =>
@@ -385,24 +451,52 @@ namespace Coffee.UIExtensions
             });
         }
 
+        /// <summary>
+        /// Clear the particles of the ParticleSystems.
+        /// </summary>
         public void Clear()
         {
             particles.Exec(p => p.Clear());
             isPaused = true;
         }
 
+        /// <summary>
+        /// Get all base materials to render.
+        /// </summary>
+        public void GetMaterials(List<Material> result)
+        {
+            if (result == null) return;
+
+            for (var i = 0; i < _renderers.Count; i++)
+            {
+                var r = _renderers[i];
+                if (!r || !r.material) continue;
+                result.Add(r.material);
+            }
+        }
+
+        /// <summary>
+        /// Refresh UIParticle using the ParticleSystem instance.
+        /// </summary>
         public void SetParticleSystemInstance(GameObject instance)
         {
             SetParticleSystemInstance(instance, true);
         }
 
+        /// <summary>
+        /// Refresh UIParticle using the ParticleSystem instance.
+        /// </summary>
         public void SetParticleSystemInstance(GameObject instance, bool destroyOldParticles)
         {
             if (!instance) return;
 
-            foreach (Transform child in transform)
+            var childCount = transform.childCount;
+            for (var i = 0; i < childCount; i++)
             {
-                var go = child.gameObject;
+                var go = transform.GetChild(i).gameObject;
+                if (go.TryGetComponent<Camera>(out var cam) && cam == _bakeCamera) continue;
+                if (go.TryGetComponent<UIParticleRenderer>(out var _)) continue;
+
                 go.SetActive(false);
                 if (destroyOldParticles)
                 {
@@ -417,6 +511,10 @@ namespace Coffee.UIExtensions
             RefreshParticles(instance);
         }
 
+        /// <summary>
+        /// Refresh UIParticle using the prefab.
+        /// The prefab is automatically instantiated.
+        /// </summary>
         public void SetParticleSystemPrefab(GameObject prefab)
         {
             if (!prefab) return;
@@ -424,16 +522,31 @@ namespace Coffee.UIExtensions
             SetParticleSystemInstance(Instantiate(prefab.gameObject), true);
         }
 
+        /// <summary>
+        /// Refresh UIParticle.
+        /// Collect ParticleSystems under the GameObject and refresh the UIParticle.
+        /// </summary>
         public void RefreshParticles()
         {
             RefreshParticles(gameObject);
         }
 
+        /// <summary>
+        /// Refresh UIParticle.
+        /// Collect ParticleSystems under the GameObject and refresh the UIParticle.
+        /// </summary>
         private void RefreshParticles(GameObject root)
         {
             if (!root) return;
             root.GetComponentsInChildren(true, particles);
-            particles.RemoveAll(x => x.GetComponentInParent<UIParticle>(true) != this);
+            for (var i = particles.Count - 1; 0 <= i; i--)
+            {
+                var ps = particles[i];
+                if (!ps || ps.GetComponentInParent<UIParticle>(true) != this)
+                {
+                    particles.RemoveAt(i);
+                }
+            }
 
             for (var i = 0; i < particles.Count; i++)
             {
@@ -448,46 +561,74 @@ namespace Coffee.UIExtensions
             RefreshParticles(particles);
         }
 
-        public void RefreshParticles(List<ParticleSystem> particles)
+        /// <summary>
+        /// Refresh UIParticle using a list of ParticleSystems.
+        /// </summary>
+        public void RefreshParticles(List<ParticleSystem> particleSystems)
         {
+            // Collect children UIParticleRenderer components.
             // #246: Nullptr exceptions when using nested UIParticle components in hierarchy
             _renderers.Clear();
-            foreach (Transform child in transform)
+            var childCount = transform.childCount;
+            for (var i = 0; i < childCount; i++)
             {
-                var uiParticleRenderer = child.GetComponent<UIParticleRenderer>();
-
-                if (uiParticleRenderer != null)
+                var child = transform.GetChild(i);
+                if (child.TryGetComponent(out UIParticleRenderer uiParticleRenderer))
                 {
                     _renderers.Add(uiParticleRenderer);
                 }
             }
 
+            // Reset the UIParticleRenderer components.
             for (var i = 0; i < _renderers.Count; i++)
             {
                 _renderers[i].Reset(i);
             }
 
+            // Set the ParticleSystem to the UIParticleRenderer. If the trail is enabled, set it additionally.
             var j = 0;
-            for (var i = 0; i < particles.Count; i++)
+            for (var i = 0; i < particleSystems.Count; i++)
             {
-                var ps = particles[i];
+                var ps = particleSystems[i];
                 if (!ps) continue;
-                GetRenderer(j++).Set(this, ps, false);
+
+                var mainEmitter = ps.GetMainEmitter(particleSystems);
+                GetRenderer(j++).Set(this, ps, false, mainEmitter);
+
+                // If the trail is enabled, set it additionally.
                 if (ps.trails.enabled)
                 {
-                    GetRenderer(j++).Set(this, ps, true);
+                    GetRenderer(j++).Set(this, ps, true, mainEmitter);
                 }
             }
         }
 
         internal void UpdateTransformScale()
         {
+            _tracker.Clear();
             canvasScale = canvas.rootCanvas.transform.localScale.Inverse();
             parentScale = transform.parent.lossyScale;
-            if (autoScalingMode != AutoScalingMode.Transform) return;
+            if (autoScalingMode != AutoScalingMode.Transform)
+            {
+                if (_isScaleStored)
+                {
+                    transform.localScale = _storedScale;
+                }
 
+                _isScaleStored = false;
+                return;
+            }
+
+            var currentScale = transform.localScale;
+            if (!_isScaleStored)
+            {
+                _storedScale = currentScale.IsVisible() ? currentScale : Vector3.one;
+                _isScaleStored = true;
+            }
+
+            _tracker.Add(this, rectTransform, DrivenTransformProperties.Scale);
             var newScale = parentScale.Inverse();
-            if (transform.localScale != newScale)
+            if (currentScale != newScale)
             {
                 transform.localScale = newScale;
             }
@@ -500,11 +641,10 @@ namespace Coffee.UIExtensions
             for (var i = 0; i < _renderers.Count; i++)
             {
                 var r = _renderers[i];
-                if (!r)
-                {
-                    RefreshParticles(particles);
-                    break;
-                }
+                if (r) continue;
+
+                RefreshParticles(particles);
+                break;
             }
 
             var bakeCamera = GetBakeCamera();
@@ -512,6 +652,7 @@ namespace Coffee.UIExtensions
             {
                 var r = _renderers[i];
                 if (!r) continue;
+
                 r.UpdateMesh(bakeCamera);
             }
         }
@@ -563,64 +704,55 @@ namespace Coffee.UIExtensions
         private Camera GetBakeCamera()
         {
             if (!canvas) return Camera.main;
-
-            // When render mode is ScreenSpaceCamera or WorldSpace, use world camera.
-            var root = canvas.rootCanvas;
-            if (root.renderMode != RenderMode.ScreenSpaceOverlay)
+            if (!useCustomView && canvas.renderMode != RenderMode.ScreenSpaceOverlay && canvas.rootCanvas.worldCamera)
             {
-                return root.worldCamera ? root.worldCamera : Camera.main;
+                return canvas.rootCanvas.worldCamera;
             }
 
-            // When render mode is ScreenSpaceOverlay, use ortho-camera.
-            if (!_orthoCamera)
+            if (_bakeCamera)
             {
-                // Find existing ortho-camera.
-                foreach (Transform child in transform)
-                {
-                    var cam = child.GetComponent<Camera>();
-                    if (cam && cam.name == "[generated] UIParticleOverlayCamera")
-                    {
-                        _orthoCamera = cam;
-                        break;
-                    }
-                }
+                _bakeCamera.orthographicSize = useCustomView ? customViewSize : 10;
+                return _bakeCamera;
+            }
 
-                // Create ortho-camera.
-                if (!_orthoCamera)
+            // Find existing baking camera.
+            var childCount = transform.childCount;
+            for (var i = 0; i < childCount; i++)
+            {
+                if (transform.GetChild(i).TryGetComponent<Camera>(out var cam)
+                    && cam.name == "[generated] UIParticle BakingCamera")
                 {
-                    var go = new GameObject("[generated] UIParticleOverlayCamera")
-                    {
-                        hideFlags = HideFlags.HideAndDontSave
-                    };
-                    go.SetActive(false);
-                    go.transform.SetParent(transform, false);
-                    _orthoCamera = go.AddComponent<Camera>();
-                    _orthoCamera.enabled = false;
+                    _bakeCamera = cam;
+                    break;
                 }
             }
 
-            //
-            var size = ((RectTransform)root.transform).rect.size;
-            _orthoCamera.orthographicSize = Mathf.Max(size.x, size.y) * root.scaleFactor;
-            _orthoCamera.transform.SetPositionAndRotation(new Vector3(0, 0, -1000), Quaternion.identity);
-            _orthoCamera.orthographic = true;
-            _orthoCamera.farClipPlane = 2000f;
-
-            return _orthoCamera;
-        }
-
-        private void UpdateTracker()
-        {
-#pragma warning disable CS0618 // Type or member is obsolete
-            if (!enabled || !autoScaling || autoScalingMode != AutoScalingMode.Transform)
-#pragma warning restore CS0618 // Type or member is obsolete
+            // Create baking camera.
+            if (!_bakeCamera)
             {
-                _tracker.Clear();
-            }
-            else
-            {
-                _tracker.Add(this, rectTransform, DrivenTransformProperties.Scale);
+                var go = new GameObject("[generated] UIParticle BakingCamera");
+                go.SetActive(false);
+                go.transform.SetParent(transform, false);
+                _bakeCamera = go.AddComponent<Camera>();
             }
+
+            // Setup baking camera.
+            _bakeCamera.enabled = false;
+            _bakeCamera.orthographicSize = useCustomView ? customViewSize : 10;
+            _bakeCamera.transform.SetPositionAndRotation(new Vector3(0, 0, -1000), Quaternion.identity);
+            _bakeCamera.orthographic = true;
+            _bakeCamera.farClipPlane = 2000f;
+            _bakeCamera.clearFlags = CameraClearFlags.Nothing;
+            _bakeCamera.cullingMask = 0; // Nothing
+            _bakeCamera.allowHDR = false;
+            _bakeCamera.allowMSAA = false;
+            _bakeCamera.renderingPath = RenderingPath.Forward;
+            _bakeCamera.useOcclusionCulling = false;
+
+            _bakeCamera.gameObject.SetActive(false);
+            _bakeCamera.gameObject.hideFlags = UIParticleProjectSettings.globalHideFlags;
+
+            return _bakeCamera;
         }
     }
 }

Runtime/UIParticle.cs.meta

@@ -5,7 +5,7 @@ MonoImporter:
   serializedVersion: 2
   defaultReferences: []
   executionOrder: 0
-  icon: {fileID: 2800000, guid: 5f0675613942149309588d556e33d990, type: 3}
+  icon: {instanceID: 0}
   userData: 
   assetBundleName: 
   assetBundleVariant: 

Runtime/UIParticleAttractor.cs

@@ -1,12 +1,13 @@
 using System;
-using Coffee.UIParticleExtensions;
+using System.Collections.Generic;
+using Coffee.UIParticleInternal;
 using UnityEngine;
 using UnityEngine.Events;
 
 namespace Coffee.UIExtensions
 {
     [ExecuteAlways]
-    public class UIParticleAttractor : MonoBehaviour
+    public class UIParticleAttractor : MonoBehaviour, ISerializationCallbackReceiver
     {
         public enum Movement
         {
@@ -22,8 +23,12 @@ namespace Coffee.UIExtensions
         }
 
         [SerializeField]
+        [HideInInspector]
         private ParticleSystem m_ParticleSystem;
 
+        [SerializeField]
+        private List<ParticleSystem> m_ParticleSystems = new List<ParticleSystem>();
+
         [Range(0.1f, 10f)]
         [SerializeField]
         private float m_DestinationRadius = 1;
@@ -45,7 +50,7 @@ namespace Coffee.UIExtensions
         [SerializeField]
         private UnityEvent m_OnAttracted;
 
-        private UIParticle _uiParticle;
+        private List<UIParticle> _uiParticles = new List<UIParticle>();
 
         public float destinationRadius
         {
@@ -84,25 +89,46 @@ namespace Coffee.UIExtensions
         }
 
         /// <summary>
-        /// The target ParticleSystem to attract.
+        /// The target ParticleSystems to attract. Use <see cref="AddParticleSystem"/> and
+        /// <see cref="RemoveParticleSystem"/> to modify the list.
         /// </summary>
-#if UNITY_EDITOR
-        public new ParticleSystem particleSystem
-#else
-        public ParticleSystem particleSystem
-#endif
+        public IReadOnlyList<ParticleSystem> particleSystems => m_ParticleSystems;
+
+        public void AddParticleSystem(ParticleSystem ps)
         {
-            get => m_ParticleSystem;
-            set
+            if (m_ParticleSystems == null)
             {
-                m_ParticleSystem = value;
-                ApplyParticleSystem();
+                m_ParticleSystems = new List<ParticleSystem>();
             }
+
+            var i = m_ParticleSystems.IndexOf(ps);
+            if (0 <= i) return; // Already added: skip
+
+            m_ParticleSystems.Add(ps);
+            _uiParticles.Clear();
+        }
+
+        public void RemoveParticleSystem(ParticleSystem ps)
+        {
+            if (m_ParticleSystems == null)
+            {
+                return;
+            }
+
+            var i = m_ParticleSystems.IndexOf(ps);
+            if (i < 0) return; // Not found. skip
+
+            m_ParticleSystems.RemoveAt(i);
+            _uiParticles.Clear();
+        }
+
+        private void Awake()
+        {
+            UpgradeIfNeeded();
         }
 
         private void OnEnable()
         {
-            ApplyParticleSystem();
             UIParticleUpdater.Register(this);
         }
 
@@ -113,85 +139,96 @@ namespace Coffee.UIExtensions
 
         private void OnDestroy()
         {
-            _uiParticle = null;
-            m_ParticleSystem = null;
+            _uiParticles = null;
+            m_ParticleSystems = null;
         }
 
         internal void Attract()
         {
-            if (m_ParticleSystem == null) return;
+            // Collect UIParticle if needed (same size as m_ParticleSystems)
+            CollectUIParticlesIfNeeded();
 
-            var count = m_ParticleSystem.particleCount;
-            if (count == 0) return;
-
-            var particles = ParticleSystemExtensions.GetParticleArray(count);
-            m_ParticleSystem.GetParticles(particles, count);
-
-            var dstPos = GetDestinationPosition();
-            for (var i = 0; i < count; i++)
+            for (var particleIndex = 0; particleIndex < m_ParticleSystems.Count; particleIndex++)
             {
-                // Attracted
-                var p = particles[i];
-                if (0f < p.remainingLifetime && Vector3.Distance(p.position, dstPos) < m_DestinationRadius)
-                {
-                    p.remainingLifetime = 0f;
-                    particles[i] = p;
+                var particleSystem = m_ParticleSystems[particleIndex];
 
-                    if (m_OnAttracted != null)
+                // Skip: The ParticleSystem is not active
+                if (particleSystem == null || !particleSystem.gameObject.activeInHierarchy) continue;
+
+                // Skip: No active particles
+                var count = particleSystem.particleCount;
+                if (count == 0) continue;
+
+                var particles = ParticleSystemExtensions.GetParticleArray(count);
+                particleSystem.GetParticles(particles, count);
+
+                var uiParticle = _uiParticles[particleIndex];
+                var dstPos = GetDestinationPosition(uiParticle, particleSystem);
+                for (var i = 0; i < count; i++)
+                {
+                    // Attracted
+                    var p = particles[i];
+                    if (0f < p.remainingLifetime && Vector3.Distance(p.position, dstPos) < m_DestinationRadius)
                     {
-                        try
+                        p.remainingLifetime = 0f;
+                        particles[i] = p;
+
+                        if (m_OnAttracted != null)
                         {
-                            m_OnAttracted.Invoke();
-                        }
-                        catch (Exception e)
-                        {
-                            Debug.LogException(e);
+                            try
+                            {
+                                m_OnAttracted.Invoke();
+                            }
+                            catch (Exception e)
+                            {
+                                Debug.LogException(e);
+                            }
                         }
+
+                        continue;
                     }
 
-                    continue;
+                    // Calc attracting time
+                    var delayTime = p.startLifetime * m_DelayRate;
+                    var duration = p.startLifetime - delayTime;
+                    var time = Mathf.Max(0, p.startLifetime - p.remainingLifetime - delayTime);
+
+                    // Delay
+                    if (time <= 0) continue;
+
+                    // Attract
+                    p.position = GetAttractedPosition(p.position, dstPos, duration, time);
+                    p.velocity *= 0.5f;
+                    particles[i] = p;
                 }
 
-                // Calc attracting time
-                var delayTime = p.startLifetime * m_DelayRate;
-                var duration = p.startLifetime - delayTime;
-                var time = Mathf.Max(0, p.startLifetime - p.remainingLifetime - delayTime);
-
-                // Delay
-                if (time <= 0) continue;
-
-                // Attract
-                p.position = GetAttractedPosition(p.position, dstPos, duration, time);
-                p.velocity *= 0.5f;
-                particles[i] = p;
+                particleSystem.SetParticles(particles, count);
             }
-
-            m_ParticleSystem.SetParticles(particles, count);
         }
 
-        private Vector3 GetDestinationPosition()
+        private Vector3 GetDestinationPosition(UIParticle uiParticle, ParticleSystem particleSystem)
         {
-            var isUI = _uiParticle && _uiParticle.enabled;
-            var psPos = m_ParticleSystem.transform.position;
+            var isUI = uiParticle && uiParticle.enabled;
+            var psPos = particleSystem.transform.position;
             var attractorPos = transform.position;
             var dstPos = attractorPos;
-            var isLocalSpace = m_ParticleSystem.IsLocalSpace();
+            var isLocalSpace = particleSystem.IsLocalSpace();
 
             if (isLocalSpace)
             {
-                dstPos = m_ParticleSystem.transform.InverseTransformPoint(dstPos);
+                dstPos = particleSystem.transform.InverseTransformPoint(dstPos);
             }
 
             if (isUI)
             {
-                var inverseScale = _uiParticle.parentScale.Inverse();
-                var scale3d = _uiParticle.scale3DForCalc;
+                var inverseScale = uiParticle.parentScale.Inverse();
+                var scale3d = uiParticle.scale3DForCalc;
                 dstPos = dstPos.GetScaled(inverseScale, scale3d.Inverse());
 
                 // Relative mode
-                if (_uiParticle.positionMode == UIParticle.PositionMode.Relative)
+                if (uiParticle.positionMode == UIParticle.PositionMode.Relative)
                 {
-                    var diff = _uiParticle.transform.position - psPos;
+                    var diff = uiParticle.transform.position - psPos;
                     diff.Scale(scale3d - inverseScale);
                     diff.Scale(scale3d.Inverse());
                     dstPos += diff;
@@ -237,25 +274,59 @@ namespace Coffee.UIExtensions
             return Vector3.MoveTowards(current, target, speed);
         }
 
-        private void ApplyParticleSystem()
+        private void CollectUIParticlesIfNeeded()
         {
-            _uiParticle = null;
-            if (m_ParticleSystem == null)
-            {
-#if UNITY_EDITOR
-                if (Application.isPlaying)
-#endif
-                {
-                    Debug.LogError("No particle system attached to particle attractor script", this);
-                }
+            if (m_ParticleSystems.Count == 0 || _uiParticles.Count != 0) return;
 
-                return;
+            // Expand capacity
+            if (_uiParticles.Capacity < m_ParticleSystems.Capacity)
+            {
+                _uiParticles.Capacity = m_ParticleSystems.Capacity;
             }
 
-            _uiParticle = m_ParticleSystem.GetComponentInParent<UIParticle>(true);
-            if (_uiParticle && !_uiParticle.particles.Contains(m_ParticleSystem))
+            // Find UIParticle that controls the ParticleSystem
+            for (var i = 0; i < m_ParticleSystems.Count; i++)
             {
-                _uiParticle = null;
+                var ps = m_ParticleSystems[i];
+                if (ps == null)
+                {
+                    _uiParticles.Add(null);
+                    continue;
+                }
+
+                var uiParticle = ps.GetComponentInParent<UIParticle>(true);
+                _uiParticles.Add(uiParticle.particles.Contains(ps) ? uiParticle : null);
+            }
+        }
+
+#if UNITY_EDITOR
+        private void OnValidate()
+        {
+            _uiParticles.Clear();
+        }
+#endif
+
+        void ISerializationCallbackReceiver.OnBeforeSerialize()
+        {
+            UpgradeIfNeeded();
+        }
+
+        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        {
+        }
+
+        private void UpgradeIfNeeded()
+        {
+            // Multiple ParticleSystems support: from 'm_ParticleSystem' to 'm_ParticleSystems'
+            if (m_ParticleSystem != null)
+            {
+                if (!m_ParticleSystems.Contains(m_ParticleSystem))
+                {
+                    m_ParticleSystems.Add(m_ParticleSystem);
+                }
+
+                m_ParticleSystem = null;
+                Debug.Log($"Upgraded!");
             }
         }
     }

Runtime/UIParticleAttractor.cs.meta

@@ -5,7 +5,7 @@ MonoImporter:
   serializedVersion: 2
   defaultReferences: []
   executionOrder: 0
-  icon: {instanceID: 0}
+  icon: {fileID: 2800000, guid: 5f0675613942149309588d556e33d990, type: 3}
   userData: 
   assetBundleName: 
   assetBundleVariant: 

Runtime/UIParticleProjectSettings.cs

@@ -0,0 +1,40 @@
+#pragma warning disable CS0414
+using Coffee.UIParticleInternal;
+using UnityEditor;
+using UnityEngine;
+
+namespace Coffee.UIExtensions
+{
+    public class UIParticleProjectSettings : PreloadedProjectSettings<UIParticleProjectSettings>
+    {
+        [Header("Setting")]
+        [SerializeField]
+        internal bool m_EnableLinearToGamma = true;
+
+        public static bool enableLinearToGamma
+        {
+            get => instance.m_EnableLinearToGamma;
+            set => instance.m_EnableLinearToGamma = value;
+        }
+
+
+        [Header("Editor")]
+        [Tooltip("Hide the automatically generated objects.\n" +
+                 "  - UIParticleRenderer\n" +
+                 "  - UIParticle BakingCamera")]
+        [SerializeField]
+        private bool m_HideGeneratedObjects = true;
+
+        public static HideFlags globalHideFlags => instance.m_HideGeneratedObjects
+            ? HideFlags.DontSave | HideFlags.NotEditable | HideFlags.HideInHierarchy | HideFlags.HideInInspector
+            : HideFlags.DontSave | HideFlags.NotEditable;
+
+#if UNITY_EDITOR
+        [SettingsProvider]
+        private static SettingsProvider CreateSettingsProvider()
+        {
+            return new PreloadedProjectSettingsProvider("Project/UI/UI Particle");
+        }
+#endif
+    }
+}

Runtime/UIParticleProjectSettings.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f22a23b9d98e440478697f4adf30e61c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 5f0675613942149309588d556e33d990, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/UIParticleRenderer.cs

@@ -6,7 +6,7 @@
 #endif
 using System;
 using System.Collections.Generic;
-using Coffee.UIParticleExtensions;
+using Coffee.UIParticleInternal;
 using UnityEditor;
 using UnityEngine;
 using UnityEngine.Profiling;
@@ -15,24 +15,23 @@ using UnityEngine.UI;
 
 namespace Coffee.UIExtensions
 {
+    [Icon("Packages/com.coffee.ui-particle/Icons/UIParticleIcon.png")]
     [ExecuteAlways]
     [RequireComponent(typeof(RectTransform))]
     [RequireComponent(typeof(CanvasRenderer))]
     [AddComponentMenu("")]
     internal class UIParticleRenderer : MaskableGraphic
     {
-        private static readonly List<Component> s_Components = new List<Component>();
         private static readonly CombineInstance[] s_CombineInstances = { new CombineInstance() };
         private static readonly List<Material> s_Materials = new List<Material>(2);
         private static MaterialPropertyBlock s_Mpb;
-        private static readonly List<UIParticleRenderer> s_Renderers = new List<UIParticleRenderer>();
-        private static readonly List<Color32> s_Colors = new List<Color32>();
         private static readonly Vector3[] s_Corners = new Vector3[4];
-        private Material _currentMaterialForRendering;
         private bool _delay;
         private int _index;
+        private bool _isPrevStored;
         private bool _isTrail;
         private Bounds _lastBounds;
+        private Material _materialForRendering;
         private Material _modifiedMaterial;
         private UIParticle _parent;
         private ParticleSystem _particleSystem;
@@ -40,8 +39,9 @@ namespace Coffee.UIExtensions
         private Vector3 _prevPsPos;
         private Vector3 _prevScale;
         private Vector2Int _prevScreenSize;
-        private bool _prewarm;
+        private bool _preWarm;
         private ParticleSystemRenderer _renderer;
+        private ParticleSystem _mainEmitter;
 
         public override Texture mainTexture => _isTrail ? null : _particleSystem.GetTextureForSprite();
 
@@ -91,6 +91,19 @@ namespace Coffee.UIExtensions
             }
         }
 
+        public override Material materialForRendering
+        {
+            get
+            {
+                if (!_materialForRendering)
+                {
+                    _materialForRendering = base.materialForRendering;
+                }
+
+                return _materialForRendering;
+            }
+        }
+
         public void Reset(int index = -1)
         {
             if (_renderer)
@@ -101,6 +114,7 @@ namespace Coffee.UIExtensions
             _parent = null;
             _particleSystem = null;
             _renderer = null;
+            _mainEmitter = null;
             if (0 <= index)
             {
                 _index = index;
@@ -110,16 +124,14 @@ namespace Coffee.UIExtensions
             if (this && isActiveAndEnabled)
             {
                 material = null;
-                workerMesh.Clear();
-                canvasRenderer.SetMesh(workerMesh);
+                canvasRenderer.Clear();
                 _lastBounds = new Bounds();
                 enabled = false;
             }
             else
             {
-                ModifiedMaterial.Remove(_modifiedMaterial);
-                _modifiedMaterial = null;
-                _currentMaterialForRendering = null;
+                MaterialRepository.Release(ref _modifiedMaterial);
+                _materialForRendering = null;
             }
         }
 
@@ -127,6 +139,7 @@ namespace Coffee.UIExtensions
         {
             base.OnEnable();
 
+            hideFlags = UIParticleProjectSettings.globalHideFlags;
             if (!s_CombineInstances[0].mesh)
             {
                 s_CombineInstances[0].mesh = new Mesh
@@ -135,17 +148,15 @@ namespace Coffee.UIExtensions
                     hideFlags = HideFlags.HideAndDontSave
                 };
             }
-
-            _currentMaterialForRendering = null;
         }
 
         protected override void OnDisable()
         {
             base.OnDisable();
 
-            ModifiedMaterial.Remove(_modifiedMaterial);
-            _modifiedMaterial = null;
-            _currentMaterialForRendering = null;
+            MaterialRepository.Release(ref _modifiedMaterial);
+            _materialForRendering = null;
+            _isPrevStored = false;
         }
 
         public static UIParticleRenderer AddRenderer(UIParticle parent, int index)
@@ -153,7 +164,7 @@ namespace Coffee.UIExtensions
             // Create renderer object.
             var go = new GameObject("[generated] UIParticleRenderer", typeof(UIParticleRenderer))
             {
-                hideFlags = HideFlags.HideAndDontSave,
+                hideFlags = UIParticleProjectSettings.globalHideFlags,
                 layer = parent.gameObject.layer
             };
 
@@ -177,12 +188,9 @@ namespace Coffee.UIExtensions
         /// </summary>
         public override Material GetModifiedMaterial(Material baseMaterial)
         {
-            _currentMaterialForRendering = null;
-
             if (!IsActive() || !_parent)
             {
-                ModifiedMaterial.Remove(_modifiedMaterial);
-                _modifiedMaterial = null;
+                MaterialRepository.Release(ref _modifiedMaterial);
                 return baseMaterial;
             }
 
@@ -192,26 +200,33 @@ namespace Coffee.UIExtensions
             var texture = mainTexture;
             if (texture == null && _parent.m_AnimatableProperties.Length == 0)
             {
-                ModifiedMaterial.Remove(_modifiedMaterial);
-                _modifiedMaterial = null;
+                MaterialRepository.Release(ref _modifiedMaterial);
                 return modifiedMaterial;
             }
 
-            //
-            var id = _parent.m_AnimatableProperties.Length == 0 ? 0 : GetInstanceID();
+            var hash = new Hash128(
+                modifiedMaterial ? (uint)modifiedMaterial.GetInstanceID() : 0,
+                texture ? (uint)texture.GetInstanceID() : 0,
+                0 < _parent.m_AnimatableProperties.Length ? (uint)GetInstanceID() : 0,
 #if UNITY_EDITOR
-            var props = EditorJsonUtility.ToJson(modifiedMaterial).GetHashCode();
+                (uint)EditorJsonUtility.ToJson(modifiedMaterial).GetHashCode()
 #else
-            var props = 0;
+                0
 #endif
-            modifiedMaterial = ModifiedMaterial.Add(modifiedMaterial, texture, id, props);
-            ModifiedMaterial.Remove(_modifiedMaterial);
-            _modifiedMaterial = modifiedMaterial;
+            );
+            if (!MaterialRepository.Valid(hash, _modifiedMaterial))
+            {
+                MaterialRepository.Get(hash, ref _modifiedMaterial, x => new Material(x.mat)
+                {
+                    hideFlags = HideFlags.HideAndDontSave,
+                    mainTexture = x.texture ? x.texture : x.mat.mainTexture
+                }, (mat: modifiedMaterial, texture));
+            }
 
-            return modifiedMaterial;
+            return _modifiedMaterial;
         }
 
-        public void Set(UIParticle parent, ParticleSystem ps, bool isTrail)
+        public void Set(UIParticle parent, ParticleSystem ps, bool isTrail, ParticleSystem mainEmitter)
         {
             _parent = parent;
             maskable = parent.maskable;
@@ -219,25 +234,22 @@ namespace Coffee.UIExtensions
             gameObject.layer = parent.gameObject.layer;
 
             _particleSystem = ps;
-            _prewarm = _particleSystem.main.prewarm;
+            _preWarm = _particleSystem.main.prewarm;
 
 #if UNITY_EDITOR
             if (Application.isPlaying)
 #endif
             {
-                if (_particleSystem.isPlaying || _prewarm)
+                if (_particleSystem.isPlaying || _preWarm)
                 {
                     _particleSystem.Clear();
                     _particleSystem.Pause();
                 }
             }
 
-            _renderer = ps.GetComponent<ParticleSystemRenderer>();
+            ps.TryGetComponent(out _renderer);
             _renderer.enabled = false;
-
-            //_emitter = emitter;
             _isTrail = isTrail;
-
             _renderer.GetSharedMaterials(s_Materials);
             material = s_Materials[isTrail ? 1 : 0];
             s_Materials.Clear();
@@ -254,6 +266,7 @@ namespace Coffee.UIExtensions
             _prevScreenSize = new Vector2Int(Screen.width, Screen.height);
             _prevCanvasScale = canvas ? canvas.scaleFactor : 1f;
             _delay = true;
+            _mainEmitter = mainEmitter;
 
             canvasRenderer.SetTexture(null);
 
@@ -291,7 +304,7 @@ namespace Coffee.UIExtensions
 
             // Simulate particles.
             Profiler.BeginSample("[UIParticle] Bake Mesh > Simulate Particles");
-            if (!_isTrail && _parent.canSimulate)
+            if (!_isTrail && _parent.canSimulate && !_mainEmitter)
             {
 #if UNITY_EDITOR
                 if (!Application.isPlaying)
@@ -404,95 +417,67 @@ namespace Coffee.UIExtensions
                 _lastBounds = bounds;
 
                 // Convert linear color to gamma color.
-                if (QualitySettings.activeColorSpace == ColorSpace.Linear)
+                if (UIParticleProjectSettings.enableLinearToGamma && canvas.ShouldGammaToLinearInMesh())
                 {
-                    Profiler.BeginSample("[UIParticleRenderer] Convert Linear to Gamma");
-                    workerMesh.GetColors(s_Colors);
-                    var count_c = s_Colors.Count;
-                    for (var i = 0; i < count_c; 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;
-                    }
-
-                    workerMesh.SetColors(s_Colors);
-                    Profiler.EndSample();
+                    workerMesh.LinearToGamma();
                 }
 
-                GetComponents(typeof(IMeshModifier), s_Components);
-                for (var i = 0; i < s_Components.Count; i++)
+                var components = InternalListPool<Component>.Rent();
+                GetComponents(typeof(IMeshModifier), components);
+                for (var i = 0; i < components.Count; i++)
                 {
 #pragma warning disable CS0618 // Type or member is obsolete
-                    ((IMeshModifier)s_Components[i]).ModifyMesh(workerMesh);
+                    ((IMeshModifier)components[i]).ModifyMesh(workerMesh);
 #pragma warning restore CS0618 // Type or member is obsolete
                 }
 
-                s_Components.Clear();
+                InternalListPool<Component>.Return(ref components);
             }
 
             Profiler.EndSample();
 
-
-            // Get grouped renderers.
-            s_Renderers.Clear();
-            if (_parent.useMeshSharing)
-            {
-                UIParticleUpdater.GetGroupedRenderers(_parent.groupId, _index, s_Renderers);
-            }
-
-            // Set mesh to the CanvasRenderer.
-            Profiler.BeginSample("[UIParticleRenderer] Set Mesh");
-            for (var i = 0; i < s_Renderers.Count; i++)
-            {
-                if (s_Renderers[i] == this) continue;
-                s_Renderers[i].canvasRenderer.SetMesh(workerMesh);
-                s_Renderers[i]._lastBounds = _lastBounds;
-            }
-
-            if (!_parent.canRender)
-            {
-                workerMesh.Clear();
-            }
-
-            canvasRenderer.SetMesh(workerMesh);
-            Profiler.EndSample();
-
             // Update animatable material properties.
             Profiler.BeginSample("[UIParticleRenderer] Update Animatable Material Properties");
-
-#if UNITY_EDITOR
-            if (_modifiedMaterial != material)
-            {
-                _renderer.GetSharedMaterials(s_Materials);
-                material = s_Materials[_isTrail ? 1 : 0];
-                s_Materials.Clear();
-                SetMaterialDirty();
-            }
-#endif
-
             UpdateMaterialProperties();
+            Profiler.EndSample();
+
+            // Get grouped renderers.
+            Profiler.BeginSample("[UIParticleRenderer] Set Mesh");
+            var renderers = InternalListPool<UIParticleRenderer>.Rent();
             if (_parent.useMeshSharing)
             {
-                if (!_currentMaterialForRendering)
-                {
-                    _currentMaterialForRendering = materialForRendering;
-                }
+                UIParticleUpdater.GetGroupedRenderers(_parent.groupId, _index, renderers);
+            }
 
-                for (var i = 0; i < s_Renderers.Count; i++)
-                {
-                    if (s_Renderers[i] == this) continue;
+            for (var i = 0; i < renderers.Count; i++)
+            {
+                var r = renderers[i];
+                if (r == this) continue;
 
-                    s_Renderers[i].canvasRenderer.materialCount = 1;
-                    s_Renderers[i].canvasRenderer.SetMaterial(_currentMaterialForRendering, 0);
-                }
+                r.canvasRenderer.SetMesh(workerMesh);
+                r._lastBounds = _lastBounds;
+                r.canvasRenderer.materialCount = 1;
+                r.canvasRenderer.SetMaterial(materialForRendering, 0);
+            }
+
+            InternalListPool<UIParticleRenderer>.Return(ref renderers);
+
+            if (_parent.canRender)
+            {
+                canvasRenderer.SetMesh(workerMesh);
+            }
+            else
+            {
+                workerMesh.Clear();
             }
 
             Profiler.EndSample();
+        }
 
-            s_Renderers.Clear();
+        public override void SetMaterialDirty()
+        {
+            _materialForRendering = null;
+            base.SetMaterialDirty();
         }
 
         /// <summary>
@@ -524,7 +509,7 @@ namespace Coffee.UIExtensions
                 && _particleSystem.main.scalingMode == ParticleSystemScalingMode.Local
                 && _parent.canvas)
             {
-                scale = scale.GetScaled(_parent.canvas.transform.localScale);
+                scale = scale.GetScaled(_parent.canvas.rootCanvas.transform.localScale);
             }
 
             Profiler.EndSample();
@@ -558,13 +543,34 @@ namespace Coffee.UIExtensions
                     return Matrix4x4.Translate(psPos)
                            * Matrix4x4.Scale(scale);
                 case ParticleSystemSimulationSpace.World:
+                    if (_isTrail)
+                    {
+                        return Matrix4x4.Translate(psPos)
+                               * Matrix4x4.Scale(scale)
+                               * Matrix4x4.Translate(-psPos);
+                    }
+
+                    if (_mainEmitter)
+                    {
+                        if (_mainEmitter.IsLocalSpace())
+                        {
+                            return Matrix4x4.Translate(psPos)
+                                   * Matrix4x4.Scale(scale)
+                                   * Matrix4x4.Translate(-psPos);
+                        }
+                        else
+                        {
+                            psPos = _particleSystem.transform.position - _mainEmitter.transform.position;
+                            return Matrix4x4.Translate(psPos)
+                                   * Matrix4x4.Scale(scale)
+                                   * Matrix4x4.Translate(-psPos);
+                        }
+                    }
+
                     return Matrix4x4.Scale(scale);
                 case ParticleSystemSimulationSpace.Custom:
                     return Matrix4x4.Translate(_particleSystem.main.customSimulationSpace.position.GetScaled(scale))
-                           //* Matrix4x4.Translate(wpos)
-                           * Matrix4x4.Scale(scale)
-                        //* Matrix4x4.Translate(-wpos)
-                        ;
+                           * Matrix4x4.Scale(scale);
                 default:
                     throw new NotSupportedException();
             }
@@ -580,15 +586,16 @@ namespace Coffee.UIExtensions
             var screenSize = new Vector2Int(Screen.width, Screen.height);
             var isWorldSpace = _particleSystem.IsWorldSpace();
             var canvasScale = _parent.canvas ? _parent.canvas.scaleFactor : 1f;
-            var resolutionChanged = _prevScreenSize != screenSize || _prevCanvasScale != canvasScale;
-            if (resolutionChanged && isWorldSpace)
+            var resolutionChanged = _prevScreenSize != screenSize
+                                    || !Mathf.Approximately(_prevCanvasScale, canvasScale);
+            if (resolutionChanged && isWorldSpace && _isPrevStored)
             {
                 // Update particle array size and get particles.
                 var size = _particleSystem.particleCount;
                 var particles = ParticleSystemExtensions.GetParticleArray(size);
                 _particleSystem.GetParticles(particles, size);
 
-                // Resolusion resolver:
+                // Resolution resolver:
                 // (psPos / scale) / (prevPsPos / prevScale) -> psPos * scale.inv * prevPsPos.inv * prevScale
                 var modifier = psPos.GetScaled(
                     scale.Inverse(),
@@ -607,6 +614,7 @@ namespace Coffee.UIExtensions
                 _delay = true;
                 _prevScale = scale;
                 _prevPsPos = psPos;
+                _isPrevStored = true;
             }
 
             _prevCanvasScale = canvas ? canvas.scaleFactor : 1f;
@@ -621,24 +629,27 @@ namespace Coffee.UIExtensions
                 : main.useUnscaledTime
                     ? Time.unscaledDeltaTime
                     : Time.deltaTime;
+            deltaTime *= _parent.timeScaleMultiplier;
 
-            // Prewarm:
-            if (0 < deltaTime && _prewarm)
+            // Pre-warm:
+            if (0 < deltaTime && _preWarm)
             {
                 deltaTime += main.duration;
-                _prewarm = false;
+                _preWarm = false;
             }
 
             // get world position.
             var isLocalSpace = _particleSystem.IsLocalSpace();
             var psTransform = _particleSystem.transform;
+            var originLocalPosition = psTransform.localPosition;
+            var originLocalRotation = psTransform.localRotation;
             var originWorldPosition = psTransform.position;
             var originWorldRotation = psTransform.rotation;
             var emission = _particleSystem.emission;
             var rateOverDistance = emission.enabled
                                    && 0 < emission.rateOverDistance.constant
                                    && 0 < emission.rateOverDistanceMultiplier;
-            if (rateOverDistance && !paused)
+            if (rateOverDistance && !paused && _isPrevStored)
             {
                 // (For rate-over-distance emission,) Move to previous scaled position, simulate (delta = 0).
                 var prevScaledPos = isLocalSpace
@@ -654,7 +665,8 @@ namespace Coffee.UIExtensions
                 : originWorldPosition.GetScaled(scale.Inverse());
             psTransform.SetPositionAndRotation(scaledPos, originWorldRotation);
             _particleSystem.Simulate(deltaTime, false, false, false);
-            psTransform.SetPositionAndRotation(originWorldPosition, originWorldRotation);
+            psTransform.localPosition = originLocalPosition;
+            psTransform.localRotation = originLocalRotation;
         }
 
 #if UNITY_EDITOR
@@ -698,12 +710,12 @@ namespace Coffee.UIExtensions
             if (s_Mpb.isEmpty) return;
 
             // #41: Copy the value from MaterialPropertyBlock to CanvasRenderer
-            if (!_modifiedMaterial) return;
+            if (!materialForRendering) return;
 
             for (var i = 0; i < _parent.m_AnimatableProperties.Length; i++)
             {
                 var ap = _parent.m_AnimatableProperties[i];
-                ap.UpdateMaterialProperties(_modifiedMaterial, s_Mpb);
+                ap.UpdateMaterialProperties(materialForRendering, s_Mpb);
             }
 
             s_Mpb.Clear();

Runtime/UIParticleUpdater.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using Coffee.UIParticleInternal;
 using UnityEditor;
 using UnityEngine;
 
@@ -39,13 +40,26 @@ namespace Coffee.UIExtensions
 
 #if UNITY_EDITOR
         [InitializeOnLoadMethod]
-#endif
-        [RuntimeInitializeOnLoadMethod]
         private static void InitializeOnLoad()
         {
-            Canvas.willRenderCanvases -= Refresh;
-            Canvas.willRenderCanvases += Refresh;
+            UIExtraCallbacks.onAfterCanvasRebuild += Refresh;
+
+            EditorApplication.playModeStateChanged += state =>
+            {
+                UIExtraCallbacks.onAfterCanvasRebuild -= Refresh;
+                if (state == PlayModeStateChange.EnteredEditMode || state == PlayModeStateChange.EnteredPlayMode)
+                {
+                    UIExtraCallbacks.onAfterCanvasRebuild += Refresh;
+                }
+            };
         }
+#else
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        private static void InitializeOnLoad()
+        {
+            UIExtraCallbacks.onAfterCanvasRebuild += Refresh;
+        }
+#endif
 
         private static void Refresh()
         {
@@ -57,9 +71,8 @@ namespace Coffee.UIExtensions
             for (var i = 0; i < s_ActiveParticles.Count; i++)
             {
                 var uip = s_ActiveParticles[i];
-                if (!uip || !uip.canvas || !uip.isPrimary || s_UpdatedGroupIds.Contains(uip.groupId)) continue;
+                if (!uip || !uip.canvas || !uip.isPrimary || !s_UpdatedGroupIds.Add(uip.groupId)) continue;
 
-                s_UpdatedGroupIds.Add(uip.groupId);
                 uip.UpdateTransformScale();
                 uip.UpdateRenderers();
             }
@@ -76,9 +89,8 @@ namespace Coffee.UIExtensions
                 {
                     uip.UpdateRenderers();
                 }
-                else if (!s_UpdatedGroupIds.Contains(uip.groupId))
+                else if (s_UpdatedGroupIds.Add(uip.groupId))
                 {
-                    s_UpdatedGroupIds.Add(uip.groupId);
                     uip.UpdateRenderers();
                 }
             }

Runtime/Utilities.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 66c42f0f30de84ca4bd8305a1188af85
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Utilities/ParticleSystemExtensions.cs

@@ -1,96 +1,11 @@
 using System;
 using System.Collections.Generic;
-using System.Reflection;
 using UnityEngine;
 using Object = UnityEngine.Object;
 
-namespace Coffee.UIParticleExtensions
+namespace Coffee.UIParticleInternal
 {
-    public static class Color32Extensions
-    {
-        private static byte[] s_LinearToGammaLut;
-
-        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 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);
-        }
-    }
-
-    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_GetActiveAtlasTextureMethodInfo = s_SpriteEditorExtensionType
-            .GetMethod("GetActiveAtlasTexture", BindingFlags.Static | BindingFlags.NonPublic);
-
-        public static Texture2D GetActualTexture(this Sprite self)
-        {
-            if (!self) return null;
-
-            if (Application.isPlaying) return self.texture;
-            var ret = s_GetActiveAtlasTextureMethodInfo.Invoke(null, new object[] { self }) as Texture2D;
-            return ret
-                ? ret
-                : self.texture;
-        }
-#else
-        internal static Texture2D GetActualTexture(this Sprite self)
-        {
-            return self ? self.texture : null;
-        }
-#endif
-    }
-
-    public static class ParticleSystemExtensions
+    internal static class ParticleSystemExtensions
     {
         private static ParticleSystem.Particle[] s_TmpParticles = new ParticleSystem.Particle[2048];
 
@@ -250,59 +165,38 @@ namespace Coffee.UIParticleExtensions
 
         public static void Exec(this List<ParticleSystem> self, Action<ParticleSystem> action)
         {
-            self.RemoveAll(p => !p);
-            self.ForEach(action);
-        }
-    }
-
-    internal static class Misc
-    {
-        public static void Destroy(Object obj)
-        {
-            if (!obj) return;
-#if UNITY_EDITOR
-            if (!Application.isPlaying)
+            foreach (var p in self)
             {
-                Object.DestroyImmediate(obj);
-            }
-            else
-#endif
-            {
-                Object.Destroy(obj);
+                if (!p) continue;
+                action.Invoke(p);
             }
         }
 
-        public static void DestroyImmediate(Object obj)
+        public static ParticleSystem GetMainEmitter(this ParticleSystem self, List<ParticleSystem> list)
         {
-            if (!obj) return;
-#if UNITY_EDITOR
-            if (Application.isEditor)
-            {
-                Object.DestroyImmediate(obj);
-            }
-            else
-#endif
-            {
-                Object.Destroy(obj);
-            }
-        }
+            if (!self || list == null || list.Count == 0) return null;
 
-#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)
+            for (var i = 0; i < list.Count; i++)
             {
-                var component = current.GetComponent<T>();
-                if (component) return component;
-                current = current.parent;
+                var parent = list[i];
+                if (parent != self && IsSubEmitterOf(self, parent)) return parent;
             }
 
             return null;
         }
-#endif
+
+        public static bool IsSubEmitterOf(this ParticleSystem self, ParticleSystem parent)
+        {
+            if (!self || !parent) return false;
+
+            var subEmitters = parent.subEmitters;
+            var count = subEmitters.subEmittersCount;
+            for (var i = 0; i < count; i++)
+            {
+                if (subEmitters.GetSubEmitterSystem(i) == self) return true;
+            }
+
+            return false;
+        }
     }
 }

Runtime/Utilities/ParticleSystemExtensions.cs.meta

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

Samples~/Demo/Scripts/UIParticle_Demo.cs

@@ -1,3 +1,4 @@
+using Coffee.UIParticleInternal;
 using UnityEngine;
 using UnityEngine.Serialization;
 using UnityEngine.UI;
@@ -51,7 +52,7 @@ namespace Coffee.UIExtensions.Demo
 
         public void EnableAnimations(bool flag)
         {
-            foreach (var animator in FindObjectsOfType<Animator>())
+            foreach (var animator in Misc.FindObjectsOfType<Animator>())
             {
                 animator.enabled = flag;
             }
@@ -79,7 +80,7 @@ namespace Coffee.UIExtensions.Demo
 
         public void UIParticle_Scale(float scale)
         {
-            foreach (var uip in FindObjectsOfType<UIParticle>())
+            foreach (var uip in Misc.FindObjectsOfType<UIParticle>())
             {
                 uip.scale = scale;
             }
@@ -87,7 +88,7 @@ namespace Coffee.UIExtensions.Demo
 
         public void ParticleSystem_WorldSpaseSimulation(bool flag)
         {
-            foreach (var p in FindObjectsOfType<ParticleSystem>())
+            foreach (var p in Misc.FindObjectsOfType<ParticleSystem>())
             {
                 var main = p.main;
                 main.simulationSpace = flag
@@ -123,7 +124,7 @@ namespace Coffee.UIExtensions.Demo
 
         public void ParticleSystem_SetScale(float scale)
         {
-            foreach (var ps in FindObjectsOfType<ParticleSystem>())
+            foreach (var ps in Misc.FindObjectsOfType<ParticleSystem>())
             {
                 ps.transform.localScale = new Vector3(scale, scale, scale);
             }

Samples~/Demo/Sprites/UIParticle_Demo_Light_Frame.png.meta

@@ -42,12 +42,12 @@ TextureImporter:
   compressionQuality: 50
   spriteMode: 1
   spriteExtrude: 1
-  spriteMeshType: 1
+  spriteMeshType: 0
   alignment: 0
   spritePivot: {x: 0.5, y: 0.5}
   spritePixelsToUnits: 100
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
-  spriteGenerateFallbackPhysicsShape: 1
+  spriteGenerateFallbackPhysicsShape: 0
   alphaUsage: 1
   alphaIsTransparency: 1
   spriteTessellationDetail: -1

Samples~/Demo/Sprites/UIParticle_Demo_Move.png.meta

@@ -27,7 +27,7 @@ TextureImporter:
   generateCubemap: 6
   cubemapConvolution: 0
   seamlessCubemap: 0
-  textureFormat: 1
+  textureFormat: 4
   maxTextureSize: 2048
   textureSettings:
     serializedVersion: 2
@@ -42,12 +42,12 @@ TextureImporter:
   compressionQuality: 50
   spriteMode: 1
   spriteExtrude: 1
-  spriteMeshType: 1
+  spriteMeshType: 0
   alignment: 0
   spritePivot: {x: 0.5, y: 0.5}
   spritePixelsToUnits: 100
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
-  spriteGenerateFallbackPhysicsShape: 1
+  spriteGenerateFallbackPhysicsShape: 0
   alphaUsage: 1
   alphaIsTransparency: 1
   spriteTessellationDetail: -1

Samples~/Demo/Sprites/UIParticle_Demo_Star.png.meta

@@ -42,12 +42,12 @@ TextureImporter:
   compressionQuality: 50
   spriteMode: 1
   spriteExtrude: 1
-  spriteMeshType: 1
+  spriteMeshType: 0
   alignment: 0
   spritePivot: {x: 0.5, y: 0.5}
   spritePixelsToUnits: 100
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
-  spriteGenerateFallbackPhysicsShape: 1
+  spriteGenerateFallbackPhysicsShape: 0
   alphaUsage: 0
   alphaIsTransparency: 1
   spriteTessellationDetail: -1

Samples~/Demo/Sprites/UIParticle_Demo_Unity-chan.png.meta

@@ -27,7 +27,7 @@ TextureImporter:
   generateCubemap: 6
   cubemapConvolution: 0
   seamlessCubemap: 0
-  textureFormat: -1
+  textureFormat: 4
   maxTextureSize: 2048
   textureSettings:
     serializedVersion: 2
@@ -42,12 +42,12 @@ TextureImporter:
   compressionQuality: 50
   spriteMode: 1
   spriteExtrude: 1
-  spriteMeshType: 1
+  spriteMeshType: 0
   alignment: 0
   spritePivot: {x: 0.5, y: 0.5}
   spritePixelsToUnits: 100
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
-  spriteGenerateFallbackPhysicsShape: 1
+  spriteGenerateFallbackPhysicsShape: 0
   alphaUsage: 1
   alphaIsTransparency: 1
   spriteTessellationDetail: -1

Samples~/Demo/UIParticle_Demo.unity

@@ -14461,7 +14461,7 @@ Canvas:
   m_GameObject: {fileID: 1074082869}
   m_Enabled: 1
   serializedVersion: 3
-  m_RenderMode: 0
+  m_RenderMode: 1
   m_Camera: {fileID: 1023393581}
   m_PlaneDistance: 100
   m_PixelPerfect: 0

Shaders/UIAdditive.shader

@@ -40,7 +40,10 @@
         Lighting Off
         ZWrite Off
         ZTest [unity_GUIZTestMode]
-        Fog { Mode Off }
+        Fog
+        {
+            Mode Off
+        }
         Blend One One
 
         ColorMask [_ColorMask]
@@ -61,18 +64,18 @@
 
             struct appdata_t
             {
-                float4 vertex   : POSITION;
-                float4 color    : COLOR;
+                float4 vertex : POSITION;
+                float4 color : COLOR;
                 float2 texcoord : TEXCOORD0;
                 UNITY_VERTEX_INPUT_INSTANCE_ID
             };
 
             struct v2f
             {
-                float4 vertex           : SV_POSITION;
-                fixed4 color            : COLOR;
-                float2 texcoord         : TEXCOORD0;
-                float4 worldPosition    : TEXCOORD1;
+                float4 vertex : SV_POSITION;
+                fixed4 color : COLOR;
+                float2 texcoord : TEXCOORD0;
+                float4 worldPosition : TEXCOORD1;
                 UNITY_VERTEX_OUTPUT_STEREO
             };
 

package.json

@@ -2,7 +2,7 @@
   "name": "com.coffee.ui-particle",
   "displayName": "UI Particle",
   "description": "This package provides a component to render particle effects for uGUI.\nThe particle rendering is maskable and sortable, without the need for an extra Camera, RenderTexture, or Canvas.",
-  "version": "4.6.6",
+  "version": "4.11.2",
   "unity": "2018.2",
   "license": "MIT",
   "repository": {