修改框架，增加渲染管线扩展包

2025-04-03 14:32:41 +08:00
parent 0cc1ec3866
commit 5917f914ba
219 changed files with 17518 additions and 1000 deletions
@@ -0,0 +1,195 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using System.IO;
+using System.Text.RegularExpressions;
+using System.Text;
+using System.Runtime.Serialization.Formatters.Binary;
+using System.Xml.Serialization;
+
+namespace AssetClean {
+    public class AssetCollector {
+        public static readonly string exportXMLPath = "referencemap.xml";
+
+        public List<string> deleteFileList = new List<string>();
+        List<CollectionData> referenceCollection = new List<CollectionData>();
+
+        public bool useCodeStrip = true;
+        public bool saveEditorExtensions = true;
+
+        public void Collection(string[] collectionFolders) {
+            try {
+
+                XmlSerializer serialize = new XmlSerializer(typeof(List<CollectionData>));
+
+                deleteFileList.Clear();
+                referenceCollection.Clear();
+
+                if (File.Exists(exportXMLPath)) {
+                    using (StreamReader fileStream = new StreamReader(exportXMLPath)) {
+                        referenceCollection = (List<CollectionData>)serialize.Deserialize(fileStream);
+                        fileStream.Close();
+                    }
+                }
+
+                List<IReferenceCollection> collectionList = new List<IReferenceCollection>();
+
+                if (useCodeStrip) {
+                    collectionList.Add(new ClassReferenceCollection(saveEditorExtensions));
+                }
+
+                collectionList.AddRange(new IReferenceCollection[] {
+                    new ShaderReferenceCollection (),
+                    new AssetReferenceCollection (),
+                });
+
+                foreach (IReferenceCollection collection in collectionList) {
+                    collection.Init(referenceCollection);
+                    collection.CollectionFiles();
+                }
+
+                // Find assets
+                var files = StripTargetPathsAll(useCodeStrip, collectionFolders);
+
+                foreach (var path in files) {
+                    var guid = AssetDatabase.AssetPathToGUID(path);
+                    deleteFileList.Add(guid);
+                }
+                EditorUtility.DisplayProgressBar("checking", "collection all files", 0.2f);
+                UnregistReferenceFromResources();
+
+                EditorUtility.DisplayProgressBar("checking", "check reference from resources", 0.4f);
+                UnregistReferenceFromScenes();
+
+                EditorUtility.DisplayProgressBar("checking", "check reference from scenes", 0.6f);
+                if (saveEditorExtensions) {
+                    UnregistEditorCodes();
+                }
+
+                EditorUtility.DisplayProgressBar("checking", "check reference from ignorelist", 0.8f);
+                UnregistReferenceFromIgnoreList();
+                UnregistReferenceFromExtensionMethod();
+
+                using (var fileStream = new StreamWriter(exportXMLPath)) {
+                    serialize.Serialize(fileStream, referenceCollection);
+                    fileStream.Close();
+                }
+
+            } finally {
+                EditorUtility.ClearProgressBar();
+            }
+        }
+
+        List<string> StripTargetPathsAll(bool isUseCodeStrip, string[] pathes) {
+            var files = pathes.SelectMany(c => Directory.GetFiles(c, "*.*", SearchOption.AllDirectories))
+                    .Distinct()
+                    .Where(item => Path.GetExtension(item) != ".meta")
+                    .Where(item => Path.GetExtension(item) != ".js")
+                    .Where(item => Path.GetExtension(item) != ".dll")
+                    .Where(item => Regex.IsMatch(item, "[\\/\\\\]Gizmos[\\/\\\\]") == false)
+                    .Where(item => Regex.IsMatch(item, "[\\/\\\\]Plugins[\\/\\\\]Android[\\/\\\\]") == false)
+                    .Where(item => Regex.IsMatch(item, "[\\/\\\\]Plugins[\\/\\\\]iOS[\\/\\\\]") == false)
+                    .Where(item => Regex.IsMatch(item, "[\\/\\\\]Resources[\\/\\\\]") == false);
+
+            if (isUseCodeStrip == false) {
+                files = files.Where(item => Path.GetExtension(item) != ".cs");
+            }
+
+            return files.ToList();
+        }
+
+        void UnregistReferenceFromIgnoreList() {
+            var codePaths = deleteFileList.Where(fileName => Path.GetExtension(fileName) == ".cs");
+
+            foreach (var path in codePaths) {
+                var code = ClassReferenceCollection.StripComment(File.ReadAllText(path));
+                if (Regex.IsMatch(code, "static\\s*(partial)*\\s*class")) {
+                    UnregistFromDelteList(AssetDatabase.AssetPathToGUID(path));
+                    continue;
+                }
+            }
+        }
+
+        void UnregistReferenceFromExtensionMethod() {
+            var resourcesFiles = deleteFileList
+                .Where(item => Path.GetExtension(item) != ".meta")
+                .ToArray();
+            foreach (var path in AssetDatabase.GetDependencies(resourcesFiles)) {
+                UnregistFromDelteList(AssetDatabase.AssetPathToGUID(path));
+            }
+        }
+
+        void UnregistReferenceFromResources() {
+            var resourcesFiles = deleteFileList
+                .Where(item => Regex.IsMatch(item, "[\\/\\\\]Resources[\\/\\\\]") == true)
+                .Where(item => Path.GetExtension(item) != ".meta")
+                .ToArray();
+            foreach (var path in AssetDatabase.GetDependencies(resourcesFiles)) {
+
+                UnregistFromDelteList(AssetDatabase.AssetPathToGUID(path));
+            }
+        }
+
+        void UnregistReferenceFromScenes() {
+            // Exclude objects that reference from scenes.
+            var scenes = EditorBuildSettings.scenes
+                .Where(item => item.enabled == true)
+                    .Select(item => item.path)
+                    .ToArray();
+            foreach (var path in AssetDatabase.GetDependencies(scenes)) {
+
+                UnregistFromDelteList(AssetDatabase.AssetPathToGUID(path));
+            }
+        }
+
+        void UnregistEditorCodes() {
+            // Exclude objects that reference from Editor API
+            var editorcodes = Directory.GetFiles("Assets", "*.*", SearchOption.AllDirectories)
+                .Where(fileName => Path.GetExtension(fileName) == ".cs")
+                .Where(item => Regex.IsMatch(item, "[\\/\\\\]Editor[\\/\\\\]") == true)
+                .ToArray();
+
+            EditorUtility.DisplayProgressBar("checking", "check reference from editor codes", 0.8f);
+
+            foreach (var path in editorcodes) {
+                var code = ClassReferenceCollection.StripComment(File.ReadAllText(path));
+                if (Regex.IsMatch(code, "(\\[MenuItem|AssetPostprocessor|EditorWindow)")) {
+                    UnregistFromDelteList(AssetDatabase.AssetPathToGUID(path));
+                    continue;
+                }
+            }
+            foreach (var path in editorcodes) {
+                var guid = AssetDatabase.AssetPathToGUID(path);
+
+                if (referenceCollection.Exists(c => c.fileGuid == guid) == false) {
+                    continue;
+                }
+
+                var referenceGuids = referenceCollection.First(c => c.fileGuid == guid).referenceGids;
+
+
+
+                if (referenceGuids.Any(c => deleteFileList.Contains(c) == true) == false) {
+                    UnregistFromDelteList(AssetDatabase.AssetPathToGUID(path));
+                }
+            }
+        }
+
+        void UnregistFromDelteList(string guid) {
+            if (deleteFileList.Contains(guid) == false) {
+                return;
+            }
+            deleteFileList.Remove(guid);
+
+            if (referenceCollection.Exists(c => c.fileGuid == guid)) {
+                var refInfo = referenceCollection.First(c => c.fileGuid == guid);
+                foreach (var referenceGuid in refInfo.referenceGids) {
+                    UnregistFromDelteList(referenceGuid);
+                }
+            }
+
+        }
+    }
+}
@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 842f43ac94b4b4f72ac0898650ddcc44
+labels:
+- ActionGame
+timeCreated: 1437724265
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,58 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using System.Linq;
+
+public class AssetReferenceCollection : IReferenceCollection {
+    public void Init(List<CollectionData> refs) {
+        references = refs;
+    }
+
+    private List<CollectionData> references = null;
+
+    public void CollectionFiles() {
+        var allFiles = Directory.GetFiles("Assets", "*.*", SearchOption.AllDirectories)
+            .Where(c => Path.GetExtension(c) != ".meta")
+            .Where(c => Path.GetExtension(c) != ".shader")
+            .Where(c => Path.GetExtension(c) != ".cg")
+            .Where(c => Path.GetExtension(c) != ".cginc")
+            .Where(c => Path.GetExtension(c) != ".cs");
+
+        foreach (var file in allFiles) {
+            CollectionReferenceAssets(file);
+        }
+    }
+
+    public void CollectionReferenceAssets(string path) {
+        string guid = AssetDatabase.AssetPathToGUID(path);
+        if (File.Exists(path) == false) { return; }
+
+        string[] referenceFiles = AssetDatabase.GetDependencies(new string[] { path });
+        List<string> referenceList = null;
+        CollectionData reference = null;
+
+        if (references.Exists(c => c.fileGuid == guid) == false) {
+            referenceList = new List<string>();
+            reference = new CollectionData() {
+                fileGuid = guid,
+                referenceGids = referenceList,
+            };
+            references.Add(reference);
+        }
+        else {
+            reference = references.Find(c => c.fileGuid == guid);
+            referenceList = reference.referenceGids;
+        }
+        if (string.IsNullOrEmpty(AssetDatabase.GUIDToAssetPath(guid)) == false) {
+            reference.timeStamp = File.GetLastWriteTime(AssetDatabase.GUIDToAssetPath(guid));
+        }
+
+        foreach (string file in referenceFiles) {
+            if (referenceList.Contains(file) == false)
+                referenceList.Add(AssetDatabase.AssetPathToGUID(file));
+        }
+    }
+
+}
@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 805140a4856714e288ea84985d3023df
+labels:
+- ActionGame
+timeCreated: 1438701927
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,356 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using UnityEditor;
+using System.IO;
+using System.Reflection;
+using System.Linq;
+using System.Xml.Serialization;
+
+namespace AssetClean {
+    public class ClassReferenceCollection : IReferenceCollection {
+        // guid : types
+        private List<CollectionData> references = null;
+
+        // type : guid
+        private Dictionary<System.Type, List<string>> code2FileDic = new Dictionary<System.Type, List<string>>();
+        private List<TypeDate> fileTypeList = null;
+        public static readonly string xmlPath = "referenceType2File.xml";
+
+        private List<TypeDate> fileTypeXML {
+            get {
+                if (File.Exists(xmlPath) == true) {
+                    using (var reader = new StreamReader(xmlPath)) {
+                        XmlSerializer serialize = new XmlSerializer(typeof(List<TypeDate>));
+                        return (List<TypeDate>)serialize.Deserialize(reader);
+                    }
+                }
+                else {
+                    return new List<TypeDate>();
+                }
+            }
+            set {
+                using (var writer = new StreamWriter(xmlPath)) {
+                    XmlSerializer serialize = new XmlSerializer(typeof(List<TypeDate>));
+                    serialize.Serialize(writer, value);
+                }
+            }
+        }
+
+        TypeDate GetTypeData(string guid) {
+            if (fileTypeList.Exists(c => c.guid == guid) == false) {
+
+                var path = AssetDatabase.GUIDToAssetPath(guid);
+
+                fileTypeList.Add(new TypeDate() {
+                    guid = guid,
+                    fileName = path,
+                    timeStamp = File.GetLastWriteTime(path)
+                });
+            }
+
+            return fileTypeList.First(c => c.guid == guid);
+        }
+
+        private bool isSaveEditorCode = false;
+
+        public ClassReferenceCollection(bool saveStiroCode = false) {
+            isSaveEditorCode = saveStiroCode;
+            fileTypeList = fileTypeXML;
+        }
+
+        public void Init(List<CollectionData> refs) {
+            references = refs;
+        }
+
+        public void CollectionFiles() {
+
+            // connect each classes.
+            var firstPassList = new List<string>();
+            if (Directory.Exists("Assets/Plugins"))
+                firstPassList.AddRange(CodeList("Assets/Plugins"));
+            if (Directory.Exists("Assets/Standard Assets"))
+                firstPassList.AddRange(CodeList("Assets/Standard Assets"));
+
+            // Connect the files and class.
+            var codes = CodeList("Assets/").Where(c => firstPassList.Contains(c) == false);
+
+            var allFirstpassTypes = collectionAllFastspassClasses();
+            CollectionCodeFileDictionary(allFirstpassTypes, firstPassList.ToArray());
+
+            var alltypes = CollectionAllClasses();
+            CollectionCodeFileDictionary(alltypes, codes.ToArray());
+            alltypes.AddRange(allFirstpassTypes);
+
+
+            fileTypeXML = fileTypeList;
+
+            foreach (var type in alltypes) {
+                List<string> list = null;
+                if (code2FileDic.ContainsKey(type) == false) {
+                    list = new List<string>();
+                    code2FileDic.Add(type, list);
+                }
+                else {
+                    list = code2FileDic[type];
+                }
+
+                var fullName = type.FullName;
+                var assembly = type.Assembly.FullName;
+                if (fileTypeList.Exists(c => c.assemblly == assembly && c.typeFullName.Contains(fullName))) {
+                    var datas = fileTypeList.Where(c => c.assemblly == assembly && c.typeFullName.Contains(fullName));
+                    foreach (var data in datas) {
+                        list.Add(data.guid);
+                    }
+                }
+            }
+
+            float count = 1, max = firstPassList.Count;
+            foreach (var codepath in firstPassList) {
+                EditorUtility.DisplayProgressBar("analytics", codepath, count++ / max);
+                CollectionReferenceClasses(AssetDatabase.AssetPathToGUID(codepath), allFirstpassTypes);
+            }
+            count = 1;
+            max = codes.Count();
+            foreach (var codepath in codes) {
+                EditorUtility.DisplayProgressBar("analytics", codepath, count++ / max);
+                CollectionReferenceClasses(AssetDatabase.AssetPathToGUID(codepath), alltypes);
+            }
+
+            if (isSaveEditorCode) {
+                CollectionCustomEditorClasses(alltypes);
+            }
+        }
+
+        List<string> CodeList(string path) {
+            string[] codes = Directory.GetFiles(path, "*.cs", SearchOption.AllDirectories);
+
+            List<string> needUpdateFileList = new List<string>();
+
+            foreach (var code in codes) {
+                var guid = AssetDatabase.AssetPathToGUID(code);
+                if (fileTypeList.Exists(c => c.guid == guid) == false) {
+                    needUpdateFileList.Add(code);
+                    continue;
+                }
+
+                var filetype = GetTypeData(guid);
+
+                var timeStamp = filetype.timeStamp;
+                var time = File.GetLastWriteTime(code);
+                if (time != timeStamp) {
+                    filetype.timeStamp = time;
+                    needUpdateFileList.Add(code);
+                    continue;
+                }
+            }
+            return needUpdateFileList;
+        }
+
+        void CollectionCodeFileDictionary(List<System.Type> alltypes, string[] codes) {
+            float count = 1;
+            foreach (var codePath in codes) {
+                EditorUtility.DisplayProgressBar("checking", "search files", count++ / codes.Length);
+
+                // connect file and classes.
+                var code = StripComment(System.IO.File.ReadAllText(codePath));
+                var guid = AssetDatabase.AssetPathToGUID(codePath);
+
+                var typeList = GetTypeData(guid);
+                typeList.typeFullName.Clear();
+
+                foreach (var type in alltypes) {
+
+                    if (type.IsNested) {
+                        continue;
+                    }
+
+                    if (string.IsNullOrEmpty(type.Namespace) == false) {
+                        var namespacepattern = string.Format("namespace\\s*{0}[{{\\s\\n]", type.Namespace);
+                        if (Regex.IsMatch(code, namespacepattern) == false) {
+                            continue;
+                        }
+                    }
+
+                    string typeName = type.IsGenericTypeDefinition ? type.GetGenericTypeDefinition().Name.Split('`')[0] : type.Name;
+                    if (type.IsClass) {
+                        if (Regex.IsMatch(code, string.Format("class\\s*{0}?[\\s:<{{]", typeName))) {
+                            typeList.Add(type);
+
+                            var nested = type.GetNestedTypes(BindingFlags.Public | BindingFlags.Instance);
+
+                            foreach (var nestedType in nested) {
+                                typeList.Add(nestedType);
+                            }
+
+                            continue;
+                        }
+                    }
+                    else if (type.IsInterface) {
+
+                        if (Regex.IsMatch(code, string.Format("interface\\s*{0}[\\s<{{]", typeName))) {
+                            typeList.Add(type);
+                            continue;
+                        }
+                    }
+                    else if (type.IsEnum) {
+
+                        if (Regex.IsMatch(code, string.Format("enum\\s*{0}[\\s{{]", type.Name))) {
+                            typeList.Add(type);
+                            continue;
+                        }
+                    }
+                    else {
+                        if (Regex.IsMatch(code, string.Format("struct\\s*{0}[\\s:<{{]", typeName))) {
+                            typeList.Add(type);
+                            continue;
+                        }
+                        if (Regex.IsMatch(code, string.Format("delegate\\s*{0}\\s\\(", typeName))) {
+                            typeList.Add(type);
+                            continue;
+                        }
+                    }
+                }
+            }
+        }
+
+        List<System.Type> CollectionAllClasses() {
+            string path = Application.dataPath;
+            string absolutePath = path.Remove(path.Length - 6);
+            List<System.Type> alltypes = new List<System.Type>();
+            if (File.Exists(absolutePath + "Library/ScriptAssemblies/Assembly-CSharp.dll"))
+                alltypes.AddRange(Assembly.LoadFile(absolutePath + "Library/ScriptAssemblies/Assembly-CSharp.dll").GetTypes());
+            if (isSaveEditorCode && File.Exists(absolutePath + "Library/ScriptAssemblies/Assembly-CSharp-Editor.dll"))
+                alltypes.AddRange(Assembly.LoadFile(absolutePath + "Library/ScriptAssemblies/Assembly-CSharp-Editor.dll").GetTypes());
+
+            return alltypes.ToList();
+        }
+
+        List<System.Type> collectionAllFastspassClasses() {
+            string path = Application.dataPath;
+            string absolutePath = path.Remove(path.Length - 6);
+            List<System.Type> alltypes = new List<System.Type>();
+            if (File.Exists(absolutePath + "Library/ScriptAssemblies/Assembly-CSharp-firstpass.dll"))
+                alltypes.AddRange(Assembly.LoadFile(absolutePath + "Library/ScriptAssemblies/Assembly-CSharp-firstpass.dll").GetTypes());
+            if (isSaveEditorCode && File.Exists(absolutePath + "Library/ScriptAssemblies/Assembly-CSharp-Editor-firstpass.dll"))
+                alltypes.AddRange(Assembly.LoadFile(absolutePath + "Library/ScriptAssemblies/Assembly-CSharp-Editor-firstpass.dll").GetTypes());
+            return alltypes;
+        }
+
+        public static string StripComment(string code) {
+            code = Regex.Replace(code, "//.*[\\n\\r]", "");
+            code = Regex.Replace(code, "/\\*.*[\\n\\r]\\*/", "");
+            return code;
+        }
+
+        void CollectionReferenceClasses(string guid, List<System.Type> types) {
+            var codePath = AssetDatabase.GUIDToAssetPath(guid);
+            if (string.IsNullOrEmpty(codePath) || File.Exists(codePath) == false) {
+                return;
+            }
+
+            var code = StripComment(System.IO.File.ReadAllText(codePath));
+
+            List<string> referenceList = null;
+            CollectionData reference = null;
+
+            if (references.Exists(c => c.fileGuid == guid) == false) {
+                referenceList = new List<string>();
+                reference = new CollectionData() {
+                    fileGuid = guid,
+                    referenceGids = referenceList,
+                };
+                references.Add(reference);
+            }
+            else {
+                reference = references.Find(c => c.fileGuid == guid);
+                referenceList = reference.referenceGids;
+            }
+
+            referenceList.Clear();
+
+            var timestamp = File.GetLastWriteTime(codePath);
+            reference.timeStamp = timestamp;
+
+            foreach (var type in types) {
+
+                if (code2FileDic.ContainsKey(type) == false || code2FileDic[type].Contains(guid)) {
+                    continue;
+                }
+
+                if (string.IsNullOrEmpty(type.Namespace) == false) {
+                    var namespacepattern = string.Format("([namespace|using][\\s]{0}[{{\\s\\r\\n\\r;]|{0}\\.)", type.Namespace);
+                    if (Regex.IsMatch(code, namespacepattern) == false) {
+                        continue;
+                    }
+                }
+
+                string match = string.Empty;
+
+                if (type.IsGenericTypeDefinition) {
+                    string typeName = type.GetGenericTypeDefinition().Name.Split('`')[0];
+                    match = string.Format("[!|&\\]\\[\\.\\s<(]{0}[\\.\\s\\n\\r>,<(){{]", typeName);
+
+                }
+                else {
+                    string typeName = type.Name.Split('`')[0].Replace("Attribute", "");
+                    match = string.Format("[!|&\\]\\[\\.\\s<(]{0}[\\.\\s\\n\\r>,<(){{\\]]", typeName);
+
+
+                    //  check Extension Methods
+
+                    if (Regex.IsMatch(code, string.Format("this\\s{0}\\s", typeName))) {
+                        foreach (var file in code2FileDic[type]) {
+                            foreach (var baseReference in references.Where(c => c.fileGuid == file)) {
+                                baseReference.referenceGids.Add(guid);
+                            }
+                        }
+                    }
+                }
+                if (Regex.IsMatch(code, match)) {
+                    var typeGuids = code2FileDic[type];
+                    foreach (var typeGuid in typeGuids) {
+
+                        if (referenceList.Contains(typeGuid) == false) {
+                            referenceList.Add(typeGuid);
+                        }
+                    }
+                }
+            }
+        }
+
+        void CollectionCustomEditorClasses(IEnumerable<System.Type> types) {
+            foreach (var type in types) {
+
+                if (code2FileDic.ContainsKey(type) == false) {
+                    continue;
+                }
+
+                var attributes = type.GetCustomAttributes(typeof(CustomEditor), true);
+                foreach (var attribute in attributes) {
+                    if (attribute is CustomEditor == false) {
+                        continue;
+                    }
+                    var customEditor = attribute as CustomEditor;
+                    var customEditorReferenceTypeField = typeof(CustomEditor).GetField("m_InspectedType", BindingFlags.Instance | BindingFlags.NonPublic);
+                    var customEditorReferenceType = (System.Type)customEditorReferenceTypeField.GetValue(customEditor);
+
+                    if (code2FileDic.ContainsKey(customEditorReferenceType) == false) {
+                        continue;
+                    }
+
+                    foreach (var filePath in code2FileDic[customEditorReferenceType]) {
+                        if (references.Exists(c => c.fileGuid == filePath) == false) {
+                            continue;
+                        }
+                        foreach (var refs in references.Where(c => c.fileGuid == filePath)) {
+                            var list = refs.referenceGids;
+                            list.AddRange(code2FileDic[type]);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 202c278a17939b24c8b79c0ee1f94d8f
+labels:
+- ActionGame
+timeCreated: 1436894500
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,42 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using System;
+using System.Linq;
+
+[System.Serializable]
+public class CollectionData {
+    public string fileGuid;
+    public string fileName;
+    public List<string> referenceGids = new List<string>();
+    public DateTime timeStamp;
+}
+
+[System.Serializable]
+public class TypeDate {
+    public string guid;
+    public string fileName;
+    public DateTime timeStamp;
+    public List<string> typeFullName = new List<string>();
+    public string assemblly;
+
+    public void Add(Type addtype) {
+        assemblly = addtype.Assembly.FullName;
+        var typeName = addtype.FullName;
+        if (typeFullName.Contains(typeName) == false) {
+            typeFullName.Add(typeName);
+        }
+    }
+
+    public Type[] types {
+        get {
+            return typeFullName.Select(c => Type.GetType(c)).ToArray();
+        }
+    }
+}
+
+public interface IReferenceCollection {
+    void CollectionFiles();
+    void Init(List<CollectionData> refs);
+}
+
@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 0d05386265df34bac8d0b6df44aa494c
+labels:
+- ActionGame
+timeCreated: 1438682377
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,214 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using System.IO;
+using System.Linq;
+
+namespace AssetClean {
+    public class FindUnusedAssetsWindow : EditorWindow {
+        AssetCollector collection = new AssetCollector();
+        List<DeleteAsset> deleteAssets = new List<DeleteAsset>();
+        Vector2 scroll;
+
+        [MenuItem("Window/Delete Unused Assets/only resource", false, 50)]
+        static void InitWithoutCode() {
+            var window = FindUnusedAssetsWindow.CreateInstance<FindUnusedAssetsWindow>();
+            window.collection.useCodeStrip = false;
+            window.collection.Collection(new string[] { "Assets" });
+            window.CopyDeleteFileList(window.collection.deleteFileList);
+
+            window.Show();
+        }
+
+        [MenuItem("Window/Delete Unused Assets/unused by editor", false, 51)]
+        static void InitWithout() {
+            var window = FindUnusedAssetsWindow.CreateInstance<FindUnusedAssetsWindow>();
+            window.collection.Collection(new string[] { "Assets" });
+            window.CopyDeleteFileList(window.collection.deleteFileList);
+
+            window.Show();
+        }
+
+        [MenuItem("Window/Delete Unused Assets/unused by game", false, 52)]
+        static void Init() {
+            FindUnusedAssetsWindow window = CreateInstance<FindUnusedAssetsWindow>();
+            window.collection.saveEditorExtensions = false;
+            window.collection.Collection(new string[] { "Assets" });
+            window.CopyDeleteFileList(window.collection.deleteFileList);
+
+            window.Show();
+        }
+
+        //		[MenuItem("Assets/Delete Unused Assets/unused by editor", false, 52)]
+        //		static void InitAssets ()
+        //		{
+        //			var paths = Selection.objects
+        //				.Select(c=>AssetDatabase.GetAssetPath(c))
+        //				.Where(c=>Directory.Exists(c));
+        //			if( paths.Any(c=> string.IsNullOrEmpty(c) ) ){
+        //				return;
+        //			}
+        //
+        //			var window = FindUnusedAssetsWindow.CreateInstance<FindUnusedAssetsWindow> ();
+        //			window.collection.Collection (paths.ToArray());
+        //			window.CopyDeleteFileList (window.collection.deleteFileList);
+        //			
+        //			window.Show ();
+        //		}
+        //
+        //		[MenuItem("Assets/Delete Unused Assets/unused by editor", true)]
+        //		static bool InitAssetsA ()
+        //		{
+        //			var paths = Selection.objects
+        //				.Select(c=>AssetDatabase.GetAssetPath(c))
+        //				.Where(c=>Directory.Exists(c));
+        //			return ! paths.Any(c=> string.IsNullOrEmpty(c) );
+        //		}
+
+
+
+        [MenuItem("Assets/Delete Unused Assets/unused only resources", false, 52)]
+        static void InitAssetsOnlyResources() {
+            var paths = Selection.objects
+                .Select(c => AssetDatabase.GetAssetPath(c))
+                    .Where(c => Directory.Exists(c));
+            if (paths.Any(c => string.IsNullOrEmpty(c))) {
+                return;
+            }
+
+            var window = FindUnusedAssetsWindow.CreateInstance<FindUnusedAssetsWindow>();
+            window.collection.useCodeStrip = false;
+            window.collection.Collection(paths.ToArray());
+            window.CopyDeleteFileList(window.collection.deleteFileList);
+
+            window.Show();
+        }
+        [MenuItem("Assets/Delete Unused Assets/unused only resources", true)]
+        static bool InitAssetsOnlyResourcesA() {
+            var paths = Selection.objects
+                .Select(c => AssetDatabase.GetAssetPath(c))
+                    .Where(c => Directory.Exists(c));
+            return !paths.Any(c => string.IsNullOrEmpty(c));
+        }
+
+        [MenuItem("Window/Delete Unused Assets/Clear cache")]
+        static void ClearCache() {
+            File.Delete(AssetClean.AssetCollector.exportXMLPath);
+            File.Delete(AssetClean.ClassReferenceCollection.xmlPath);
+
+            EditorUtility.DisplayDialog("clear file", "clear file", "OK");
+        }
+
+
+        void OnGUI() {
+            using (var horizonal = new EditorGUILayout.HorizontalScope("box")) {
+                EditorGUILayout.LabelField("delete unreference assets from buildsettings and resources");
+            }
+
+            using (var scrollScope = new EditorGUILayout.ScrollViewScope(scroll)) {
+                scroll = scrollScope.scrollPosition;
+                foreach (var asset in deleteAssets) {
+                    if (string.IsNullOrEmpty(asset.path)) {
+                        continue;
+                    }
+
+                    using (var horizonal = new EditorGUILayout.HorizontalScope()) {
+                        asset.isDelete = EditorGUILayout.Toggle(asset.isDelete, GUILayout.Width(20));
+                        var icon = AssetDatabase.GetCachedIcon(asset.path);
+                        GUILayout.Label(icon, GUILayout.Width(20), GUILayout.Height(20));
+                        if (GUILayout.Button(asset.path, EditorStyles.largeLabel)) {
+                            Selection.activeObject = AssetDatabase.LoadAssetAtPath<Object>(asset.path);
+                        }
+                    }
+                }
+
+
+            }
+            using (var horizonal = new EditorGUILayout.HorizontalScope("box")) {
+                EditorGUILayout.Space();
+                if (GUILayout.Button("Exclude from Project", GUILayout.Width(160)) && deleteAssets.Count != 0) {
+                    EditorApplication.delayCall += Exclude;
+                }
+            }
+
+        }
+
+        void Exclude() {
+            RemoveFiles();
+            Close();
+        }
+
+        static void CleanDir() {
+            RemoveEmptyDirectry("Assets");
+            AssetDatabase.Refresh();
+        }
+
+        void CopyDeleteFileList(IEnumerable<string> deleteFileList) {
+            foreach (var asset in deleteFileList) {
+                var filePath = AssetDatabase.GUIDToAssetPath(asset);
+                if (string.IsNullOrEmpty(filePath) == false) {
+                    deleteAssets.Add(new DeleteAsset() { path = filePath });
+                }
+            }
+        }
+
+        void RemoveFiles() {
+            try {
+                string exportDirectry = "BackupUnusedAssets";
+                Directory.CreateDirectory(exportDirectry);
+                var files = deleteAssets.Where(item => item.isDelete == true).Select(item => item.path).ToArray();
+                string backupPackageName = exportDirectry + "/package" + System.DateTime.Now.ToString("yyyyMMddHHmmss") + ".unitypackage";
+                EditorUtility.DisplayProgressBar("export package", backupPackageName, 0);
+
+                AssetDatabase.ExportPackage(files, backupPackageName);
+
+                int i = 0;
+                int length = deleteAssets.Count;
+
+                foreach (var assetPath in files) {
+                    i++;
+                    EditorUtility.DisplayProgressBar("delete unused assets", assetPath, (float)i / length);
+                    AssetDatabase.DeleteAsset(assetPath);
+                    if (File.Exists(assetPath)) {
+                        File.Delete(assetPath);
+                    }
+                }
+
+                EditorUtility.DisplayProgressBar("clean directory", "", 1);
+                foreach (var dir in Directory.GetDirectories("Assets")) {
+                    RemoveEmptyDirectry(dir);
+                }
+
+                System.Diagnostics.Process.Start(exportDirectry);
+
+                AssetDatabase.Refresh();
+            }
+            catch (System.Exception e) {
+                Debug.Log(e.Message);
+            } finally {
+                EditorUtility.ClearProgressBar();
+            }
+        }
+
+        static void RemoveEmptyDirectry(string path) {
+            var dirs = Directory.GetDirectories(path);
+            foreach (var dir in dirs) {
+                RemoveEmptyDirectry(dir);
+            }
+
+
+            var files = Directory.GetFiles(path, "*", SearchOption.TopDirectoryOnly).Where(item => Path.GetExtension(item) != ".meta");
+            if (files.Count() == 0 && Directory.GetDirectories(path).Count() == 0) {
+                var metaFile = AssetDatabase.GetTextMetaFilePathFromAssetPath(path);
+                UnityEditor.FileUtil.DeleteFileOrDirectory(path);
+                UnityEditor.FileUtil.DeleteFileOrDirectory(metaFile);
+            }
+        }
+
+        class DeleteAsset {
+            public bool isDelete = true;
+            public string path;
+        }
+    }
+}
@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 74eec3bfba0594259ac2843353c082a3
+labels:
+- ActionGame
+timeCreated: 1437724294
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,95 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.RegularExpressions;
+using UnityEditor;
+
+namespace AssetClean {
+    public class ShaderReferenceCollection : IReferenceCollection {
+        // shader name / shader file guid
+        public Dictionary<string, string> shaderFileList = new Dictionary<string, string>();
+        private List<CollectionData> references = new List<CollectionData>();
+
+        public void Init(List<CollectionData> refs) {
+            references = refs;
+        }
+
+        public void CollectionFiles() {
+            CollectionShaderFiles();
+            CheckReference();
+        }
+
+        void CollectionShaderFiles() {
+            var shaderFiles = Directory.GetFiles("Assets", "*.shader", SearchOption.AllDirectories);
+            foreach (var shaderFilePath in shaderFiles) {
+                var code = File.ReadAllText(shaderFilePath);
+                var match = Regex.Match(code, "Shader \"(?<name>.*)\"");
+                if (match.Success) {
+                    var shaderName = match.Groups["name"].ToString();
+                    if (shaderFileList.ContainsKey(shaderName) == false) {
+                        shaderFileList.Add(shaderName, AssetDatabase.AssetPathToGUID(shaderFilePath));
+                    }
+                }
+            }
+
+            var cgFiles = Directory.GetFiles("Assets", "*.cg", SearchOption.AllDirectories);
+            foreach (var cgFilePath in cgFiles) {
+                var file = Path.GetFileName(cgFilePath);
+                shaderFileList.Add(file, cgFilePath);
+            }
+
+            var cgincFiles = Directory.GetFiles("Assets", "*.cginc", SearchOption.AllDirectories);
+            foreach (var cgincPath in cgincFiles) {
+                var file = Path.GetFileName(cgincPath);
+                if (shaderFileList.ContainsKey(file) == false) {
+                    shaderFileList.Add(file, cgincPath);
+                }
+            }
+        }
+
+        void CheckReference() {
+            foreach (var shader in shaderFileList) {
+                var shaderFilePath = AssetDatabase.GUIDToAssetPath(shader.Value);
+                if (File.Exists(shaderFilePath) == false) {
+                    continue;
+                }
+
+                var guid = shader.Value;
+
+                List<string> referenceList = null;
+                CollectionData reference = null;
+
+                if (references.Exists(c => c.fileGuid == guid) == false) {
+                    referenceList = new List<string>();
+                    reference = new CollectionData() {
+                        fileGuid = guid,
+                        referenceGids = referenceList,
+                    };
+                    references.Add(reference);
+                }
+                else {
+                    reference = references.Find(c => c.fileGuid == guid);
+                    referenceList = reference.referenceGids;
+                }
+
+                reference.timeStamp = File.GetLastWriteTime(AssetDatabase.GUIDToAssetPath(guid));
+
+                var code = ClassReferenceCollection.StripComment(File.ReadAllText(shaderFilePath));
+
+                foreach (var checkingShaderName in shaderFileList.Keys) {
+                    if (checkingShaderName == shader.Key) {
+                        continue;
+                    }
+
+                    if (code.IndexOf(checkingShaderName) != -1 && shaderFileList.ContainsKey(checkingShaderName)) {
+                        var fileGuid = shaderFileList[checkingShaderName];
+                        if (referenceList.Contains(fileGuid) == false) {
+                            referenceList.Add(fileGuid);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 2c4f01a79a77a45a9a84004cc2b78098
+labels:
+- ActionGame
+timeCreated: 1437706430
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: