备份CatanBuilding瘦身独立工程

LocalPackages/SoftMaskForUGUI/Scripts/Editor/Coffee.SoftMaskForUGUI.Editor.asmdef

@@ -0,0 +1,10 @@
+{
+    "name": "Coffee.SoftMaskForUGUI.Editor",
+    "references": [
+        "Coffee.SoftMaskForUGUI"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": []
+}

LocalPackages/SoftMaskForUGUI/Scripts/Editor/Coffee.SoftMaskForUGUI.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e8f1dfda17cbd45ad95e761ca8c9b120
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/SoftMaskForUGUI/Scripts/Editor/EditorUtils.cs

@@ -0,0 +1,56 @@
+#if UNITY_2018_3_OR_NEWER
+using UnityEditor.Experimental.SceneManagement;
+#endif
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+
+namespace Coffee.UISoftMask
+{
+    internal static class EditorUtils
+    {
+        internal static void MarkPrefabDirty()
+        {
+#if UNITY_2018_3_OR_NEWER
+            var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
+            if (prefabStage == null) return;
+            EditorSceneManager.MarkSceneDirty(prefabStage.scene);
+#endif
+        }
+
+        /// <summary>
+        /// Verify whether it can be converted to the specified component.
+        /// </summary>
+        internal static bool CanConvertTo<T>(Object context) where T : MonoBehaviour
+        {
+            return context && context.GetType() != typeof(T);
+        }
+
+        /// <summary>
+        /// Convert to the specified component.
+        /// </summary>
+        internal static void ConvertTo<T>(Object context) where T : MonoBehaviour
+        {
+            var target = context as MonoBehaviour;
+            var so = new SerializedObject(target);
+            so.Update();
+
+            var oldEnable = target.enabled;
+            target.enabled = false;
+
+            // Find MonoScript of the specified component.
+            foreach (var script in Resources.FindObjectsOfTypeAll<MonoScript>())
+            {
+                if (script.GetClass() != typeof(T))
+                    continue;
+
+                // Set 'm_Script' to convert.
+                so.FindProperty("m_Script").objectReferenceValue = script;
+                so.ApplyModifiedProperties();
+                break;
+            }
+
+            (so.targetObject as MonoBehaviour).enabled = oldEnable;
+        }
+    }
+}

LocalPackages/SoftMaskForUGUI/Scripts/Editor/EditorUtils.cs.meta

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

LocalPackages/SoftMaskForUGUI/Scripts/Editor/ImportSampleMenu.cs

@@ -0,0 +1,82 @@
+#if !UNITY_2019_1_OR_NEWER
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using UnityEditor;
+
+namespace Coffee.UISoftMask
+{
+    public static class ImportSampleMenu
+    {
+        private const string jsonGuid = "c43fd233e88b347cdabc530c23ffe30a";
+
+        [MenuItem("Assets/Samples/UISoftMask/Import Demo")]
+        private static void ImportDemo()
+        {
+            ImportSample(jsonGuid, "Demo");
+        }
+
+        [MenuItem("Assets/Samples/UISoftMask/Import TextMeshPro Support")]
+        private static void ImportTextMeshProSupport()
+        {
+            ImportSample(jsonGuid, "TextMeshProSupport");
+        }
+
+        private static void ImportSample(string jsonGuid, string sampleName)
+        {
+            var jsonPath = AssetDatabase.GUIDToAssetPath(jsonGuid);
+            var packageRoot = Path.GetDirectoryName(jsonPath).Replace('\\', '/');
+            var json = File.ReadAllText(jsonPath);
+            var version = Regex.Match(json, "\"version\"\\s*:\\s*\"([^\"]+)\"").Groups[1].Value;
+            var displayName = Regex.Match(json, "\"displayName\"\\s*:\\s*\"([^\"]+)\"").Groups[1].Value;
+            var src = string.Format("{0}/Samples~/{1}", packageRoot, sampleName);
+            var srcAlt = string.Format("{0}/Samples/{1}", packageRoot, sampleName);
+            var dst = string.Format("Assets/Samples/{0}/{1}/{2}", displayName, version, sampleName);
+            var previousPath = GetPreviousSamplePath(displayName, sampleName);
+
+            // Remove the previous sample directory.
+            if (!string.IsNullOrEmpty(previousPath))
+            {
+                var msg = "A different version of the sample is already imported at\n\n"
+                          + previousPath
+                          + "\n\nIt will be deleted when you update. Are you sure you want to continue?";
+                if (!EditorUtility.DisplayDialog("Sample Importer", msg, "OK", "Cancel"))
+                    return;
+
+                FileUtil.DeleteFileOrDirectory(previousPath);
+
+                var metaFile = previousPath + ".meta";
+                if (File.Exists(metaFile))
+                    FileUtil.DeleteFileOrDirectory(metaFile);
+            }
+
+            if (!Directory.Exists(dst))
+                FileUtil.DeleteFileOrDirectory(dst);
+
+            var dstDir = Path.GetDirectoryName(dst);
+            if (!Directory.Exists(dstDir))
+                Directory.CreateDirectory(dstDir);
+
+            if (Directory.Exists(src))
+                FileUtil.CopyFileOrDirectory(src, dst);
+            else if (Directory.Exists(srcAlt))
+                FileUtil.CopyFileOrDirectory(srcAlt, dst);
+            else
+                throw new DirectoryNotFoundException(src);
+
+            AssetDatabase.Refresh(ImportAssetOptions.ImportRecursive);
+        }
+
+        private static string GetPreviousSamplePath(string displayName, string sampleName)
+        {
+            var sampleRoot = string.Format("Assets/Samples/{0}", displayName);
+            var sampleRootInfo = new DirectoryInfo(sampleRoot);
+            if (!sampleRootInfo.Exists) return null;
+
+            return sampleRootInfo.GetDirectories()
+                .Select(versionDir => Path.Combine(versionDir.ToString(), sampleName))
+                .FirstOrDefault(Directory.Exists);
+        }
+    }
+}
+#endif

LocalPackages/SoftMaskForUGUI/Scripts/Editor/ImportSampleMenu.cs.meta

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

LocalPackages/SoftMaskForUGUI/Scripts/Editor/SoftMaskEditor.cs

@@ -0,0 +1,128 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEditor;
+using System.Linq;
+
+
+namespace Coffee.UISoftMask
+{
+    /// <summary>
+    /// SoftMask editor.
+    /// </summary>
+    [CustomEditor(typeof(SoftMask))]
+    [CanEditMultipleObjects]
+    public class SoftMaskEditor : Editor
+    {
+        private const int k_PreviewSize = 128;
+        private const string k_PrefsPreview = "SoftMaskEditor_Preview";
+        private static readonly List<Graphic> s_Graphics = new List<Graphic>();
+        private static bool s_Preview;
+
+        private void OnEnable()
+        {
+            s_Preview = EditorPrefs.GetBool(k_PrefsPreview, false);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+
+            var current = target as SoftMask;
+            current.GetComponentsInChildren<Graphic>(true, s_Graphics);
+            var fixTargets = s_Graphics
+                .Where(x => x.gameObject != current.gameObject)
+                .Where(x => !x.GetComponent<SoftMaskable>() && (!x.GetComponent<Mask>() || x.GetComponent<Mask>().showMaskGraphic))
+                .ToList();
+            if (0 < fixTargets.Count)
+            {
+                GUILayout.BeginHorizontal();
+                EditorGUILayout.HelpBox("There are child Graphics that does not have a SoftMaskable component.\nAdd SoftMaskable component to them.", MessageType.Warning);
+                GUILayout.BeginVertical();
+                if (GUILayout.Button("Fix"))
+                {
+                    foreach (var p in fixTargets)
+                    {
+                        p.gameObject.AddComponent<SoftMaskable>();
+                    }
+
+                    EditorUtils.MarkPrefabDirty();
+                }
+
+                if (GUILayout.Button("Ping"))
+                {
+                    EditorGUIUtility.PingObject(fixTargets[0]);
+                }
+
+                GUILayout.EndVertical();
+                GUILayout.EndHorizontal();
+            }
+
+            var currentImage = current.graphic as Image;
+            if (currentImage && IsMaskUI(currentImage.sprite))
+            {
+                GUILayout.BeginHorizontal();
+                EditorGUILayout.HelpBox("SoftMask does not recommend to use 'UIMask' sprite as a source image.\n(It contains only small alpha pixels.)\nDo you want to use 'UISprite' instead?", MessageType.Warning);
+                GUILayout.BeginVertical();
+
+                if (GUILayout.Button("Fix"))
+                {
+                    currentImage.sprite = AssetDatabase.GetBuiltinExtraResource<Sprite>("UI/Skin/UISprite.psd");
+                }
+
+                GUILayout.EndVertical();
+                GUILayout.EndHorizontal();
+            }
+
+            // Preview buffer.
+            GUILayout.BeginVertical(EditorStyles.helpBox);
+            if (s_Preview != (s_Preview = EditorGUILayout.ToggleLeft("Preview Soft Mask Buffer", s_Preview)))
+            {
+                EditorPrefs.SetBool(k_PrefsPreview, s_Preview);
+            }
+
+            if (s_Preview)
+            {
+                var tex = current.softMaskBuffer;
+                var width = tex.width * k_PreviewSize / tex.height;
+                EditorGUI.DrawPreviewTexture(GUILayoutUtility.GetRect(width, k_PreviewSize), tex, null, ScaleMode.ScaleToFit);
+                Repaint();
+            }
+
+            GUILayout.EndVertical();
+        }
+
+        private static bool IsMaskUI(Object obj)
+        {
+            return obj
+                   && obj.name == "UIMask"
+                   && AssetDatabase.GetAssetPath(obj) == "Resources/unity_builtin_extra";
+        }
+
+
+        //%%%% Context menu for editor %%%%
+        [MenuItem("CONTEXT/Mask/Convert To SoftMask", true)]
+        private static bool _ConvertToSoftMask(MenuCommand command)
+        {
+            return EditorUtils.CanConvertTo<SoftMask>(command.context);
+        }
+
+        [MenuItem("CONTEXT/Mask/Convert To SoftMask", false)]
+        private static void ConvertToSoftMask(MenuCommand command)
+        {
+            EditorUtils.ConvertTo<SoftMask>(command.context);
+        }
+
+        [MenuItem("CONTEXT/Mask/Convert To Mask", true)]
+        private static bool _ConvertToMask(MenuCommand command)
+        {
+            return EditorUtils.CanConvertTo<Mask>(command.context);
+        }
+
+        [MenuItem("CONTEXT/Mask/Convert To Mask", false)]
+        private static void ConvertToMask(MenuCommand command)
+        {
+            EditorUtils.ConvertTo<Mask>(command.context);
+        }
+    }
+}

LocalPackages/SoftMaskForUGUI/Scripts/Editor/SoftMaskEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c2615ef08e99d4d898049fb9da8626c6
+timeCreated: 1539820794
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/SoftMaskForUGUI/Scripts/Editor/SoftMaskableEditor.cs

@@ -0,0 +1,138 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEditor;
+using MaskIntr = UnityEngine.SpriteMaskInteraction;
+
+namespace Coffee.UISoftMask
+{
+    internal enum MaskInteraction : int
+    {
+        VisibleInsideMask = (1 << 0) + (1 << 2) + (1 << 4) + (1 << 6),
+        VisibleOutsideMask = (2 << 0) + (2 << 2) + (2 << 4) + (2 << 6),
+        Custom = -1,
+    }
+
+    /// <summary>
+    /// SoftMaskable editor.
+    /// </summary>
+    [CustomEditor(typeof(SoftMaskable))]
+    [CanEditMultipleObjects]
+    public class SoftMaskableEditor : Editor
+    {
+        private static readonly List<Mask> s_TmpMasks = new List<Mask>();
+        private static GUIContent s_MaskWarning;
+        private SerializedProperty _spMaskInteraction;
+        private bool _custom;
+
+        private MaskInteraction maskInteraction
+        {
+            get
+            {
+                var value = _spMaskInteraction.intValue;
+                return _custom
+                    ? MaskInteraction.Custom
+                    : System.Enum.IsDefined(typeof(MaskInteraction), value)
+                        ? (MaskInteraction) value
+                        : MaskInteraction.Custom;
+            }
+            set
+            {
+                _custom = (value == MaskInteraction.Custom);
+                if (!_custom)
+                {
+                    _spMaskInteraction.intValue = (int) value;
+                }
+            }
+        }
+
+
+        private void OnEnable()
+        {
+            _spMaskInteraction = serializedObject.FindProperty("m_MaskInteraction");
+            _custom = (maskInteraction == MaskInteraction.Custom);
+
+            if (s_MaskWarning == null)
+            {
+                s_MaskWarning = new GUIContent(EditorGUIUtility.FindTexture("console.warnicon.sml"), "This is not a SoftMask component.");
+            }
+        }
+
+        private void DrawMaskInteractions()
+        {
+            var softMaskable = target as SoftMaskable;
+            if (softMaskable == null) return;
+
+            softMaskable.GetComponentsInParent<Mask>(true, s_TmpMasks);
+            s_TmpMasks.RemoveAll(x => !x.enabled);
+            s_TmpMasks.Reverse();
+
+            maskInteraction = (MaskInteraction) EditorGUILayout.EnumPopup("Mask Interaction", maskInteraction);
+            if (!_custom) return;
+
+            var l = EditorGUIUtility.labelWidth;
+            EditorGUIUtility.labelWidth = 45;
+
+            using (var ccs = new EditorGUI.ChangeCheckScope())
+            {
+                var intr0 = DrawMaskInteraction(0);
+                var intr1 = DrawMaskInteraction(1);
+                var intr2 = DrawMaskInteraction(2);
+                var intr3 = DrawMaskInteraction(3);
+
+                if (ccs.changed)
+                {
+                    _spMaskInteraction.intValue = (intr0 << 0) + (intr1 << 2) + (intr2 << 4) + (intr3 << 6);
+                }
+            }
+
+            EditorGUIUtility.labelWidth = l;
+        }
+
+        private int DrawMaskInteraction(int layer)
+        {
+            var mask = layer < s_TmpMasks.Count ? s_TmpMasks[layer] : null;
+            var intr = (MaskIntr) ((_spMaskInteraction.intValue >> layer * 2) & 0x3);
+            if (!mask)
+            {
+                return (int) intr;
+            }
+
+            GUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField(mask is SoftMask ? GUIContent.none : s_MaskWarning, GUILayout.Width(16));
+            GUILayout.Space(-5);
+            EditorGUILayout.ObjectField("Mask " + layer, mask, typeof(Mask), false);
+            GUILayout.Space(-15);
+            intr = (MaskIntr) EditorGUILayout.EnumPopup(intr);
+            GUILayout.EndHorizontal();
+
+            return (int) intr;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+
+            serializedObject.Update();
+            DrawMaskInteractions();
+
+            serializedObject.ApplyModifiedProperties();
+
+            var current = target as SoftMaskable;
+            if (current == null) return;
+
+            var mask = current.softMask;
+            if (mask) return;
+
+            GUILayout.BeginHorizontal();
+            EditorGUILayout.HelpBox("This is unnecessary SoftMaskable.\nCan't find any SoftMask components above.", MessageType.Warning);
+            if (GUILayout.Button("Remove", GUILayout.Height(40)))
+            {
+                DestroyImmediate(current);
+                EditorUtils.MarkPrefabDirty();
+            }
+
+            GUILayout.EndHorizontal();
+        }
+    }
+}

LocalPackages/SoftMaskForUGUI/Scripts/Editor/SoftMaskableEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e2f5fc58cb78640d9abbb950e92109b6
+timeCreated: 1539820794
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: