AssetBundle打包工具提交

Author: carbers

Assets/BundleBuildTool.meta

@@ -0,0 +1,128 @@
+using UnityEditor;
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace BundleManager
+{
+    public static class AssetDepend
+    {
+        public static string[] GetDependenciesCache(string assetPath)
+        {
+            string[] files = { assetPath };
+            return GetDependenciesCache(files);
+        }
+
+        public static string[] GetDependenciesCache(string[] files)
+        {
+            List<string> ret = new List<string>();
+            for (int i = 0; i < files.Length; ++i)
+            {
+                DependData data = null;
+                m_dict.TryGetValue(files[i], out data);
+
+                if (data == null)
+                {
+                    string[] deps = GetDependencies(files[i]);
+                    data = new DependData();
+                    data.assetPath = files[i];
+                    data.dependPath = deps;
+                    data.InterString();
+                    m_dict.Add(data.assetPath, data);
+                }
+                ret.AddRange(data.dependPath);
+            }
+            return ret.ToArray();
+        }
+
+        public static string[] GetDependencies(string file)
+        {
+            string[] files = { file };
+            return GetDependencies(files);
+        }
+
+        public static string[] GetDependencies(string[] files)
+        {
+            Dictionary<string, string> dict = new Dictionary<string, string>();
+            for (int i = 0; i < files.Length; ++i)
+            {
+                if (!dict.ContainsKey(files[i]))
+                {
+                    dict.Add(files[i], files[i]);
+                }
+                getDependencies(files[i], dict);
+            }
+            return new List<string>(dict.Keys).ToArray();
+        }
+
+        private static void getDependencies(string file, Dictionary<string, string> dict)
+        {
+            string main_ext = System.IO.Path.GetExtension(file).ToLower();
+            string[] dep = AssetDatabase.GetDependencies(file, false);
+
+            // dirty material has dirty texture dependencies
+            if (main_ext == ".mat")
+            {
+                Material mat = AssetDatabase.LoadAssetAtPath<Material>(file);
+                if (mat == null)
+                {
+                    return;
+                }
+                MaterialProperty[] proTes = MaterialEditor.GetMaterialProperties(new Object[] {mat});
+                for (int i = 0; i < proTes.Length; ++i)
+                {
+                    if (proTes[i].type == MaterialProperty.PropType.Texture)
+                    {
+                        Texture tex = mat.GetTexture(proTes[i].name);
+                        string path = AssetDatabase.GetAssetPath(tex);
+                        if (!dict.ContainsKey(path))
+                        {
+                            dict.Add(path, path);
+                        }
+                    }
+                }
+                for (int i = 0; i < dep.Length; ++i)
+                {
+                    // assume material only depencies Texture & Shader
+                    if (dep[i].EndsWith(".shader") && !dict.ContainsKey(dep[i]))
+                    {
+                        dict.Add(dep[i], dep[i]);
+                    }
+                }
+                Resources.UnloadAsset(mat);
+            }
+            else
+            {
+                for (int i = 0; i < dep.Length; ++i)
+                {
+                    if (!dict.ContainsKey(dep[i]))
+                    {
+                        dict.Add(dep[i], dep[i]);
+                        getDependencies(dep[i], dict);
+                    }
+                }
+            }
+        }
+
+        private class DependData
+        {
+            public string assetPath;
+            public string[] dependPath;
+
+            public void InterString()
+            {
+                assetPath = string.Intern(assetPath);
+                for (int i = 0; dependPath != null && i < dependPath.Length; ++i)
+                {
+                    dependPath[i] = string.Intern(dependPath[i]);
+                }
+            }
+        }
+
+        public static void Clear()
+        {
+            m_dict.Clear();
+        }
+
+        private static Dictionary<string, DependData> m_dict = new Dictionary<string, DependData>();
+    }
+}

Assets/BundleBuildTool/Src.meta

@@ -0,0 +1,76 @@
+using System;
+using System.IO;
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+
+namespace BundleManager
+{
+    public delegate List<UnityEngine.Object> FilterDelegate(UnityEngine.Object[] assets, BundleType bundleType, string assetPath);
+
+    public class AssetFilter
+    {
+        public static void ClearFilter()
+        {
+            m_filterList.Clear();
+        }
+        public static void RegisterFilter(FilterDelegate filterDelegate)
+        {
+            m_filterList.Add(filterDelegate);
+        }
+        public static List<UnityEngine.Object> FilterObjectByType(UnityEngine.Object[] assetsAtPath, BundleType bundleType, string assetPath)
+        {
+            List<UnityEngine.Object> ret = new List<UnityEngine.Object>();
+            switch (bundleType)
+            {
+            case BundleType.FBX:
+                foreach (UnityEngine.Object obj in assetsAtPath)
+                {
+                    if (obj == null)
+                        continue;
+                    Type type = obj.GetType();
+                    if (type == typeof(AnimationClip) && obj.name != EditorConst.EDITOR_ANICLIP_NAME)
+                    {
+                        ret.Add(obj);
+                    }
+                    else
+                    {
+                        ret.Add(obj);
+                    }
+                }
+                break;
+            case BundleType.Controller:
+                foreach (UnityEngine.Object obj in assetsAtPath)
+                {
+
+                    if (obj == null)
+                        continue;
+                    string typeName = obj.GetType().ToString();
+                    if (typeName.Contains("AnimatorStateMachine") || typeName.Contains("AnimatorStateTransition") ||
+                        typeName.Contains("AnimatorState") || typeName.Contains("AnimatorTransition") ||
+                        typeName.Contains("BlendTree"))
+                        continue;
+                    ret.Add(obj);
+                }
+
+                break;
+            default:
+                ret.AddRange(assetsAtPath);
+                break;
+            }
+            if (ret.Count == 0)
+            {
+                ret.AddRange(assetsAtPath);
+            }
+
+            for (int i = 0; i < m_filterList.Count; ++i)
+            {
+                ret = m_filterList[i](ret.ToArray(), bundleType, assetPath);
+            }
+
+            return ret;
+        }
+
+        private static List<FilterDelegate> m_filterList = new List<FilterDelegate>();
+    }
+}

Assets/BundleBuildTool/Src/Editor.meta

@@ -0,0 +1,26 @@
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace BundleManager
+{
+    public class AssetPathInfo
+    {
+        public string Path = "Unknown";
+        // Index Of BundleImportData
+        public int Index = -1;
+
+        public static AssetPathInfo CreatePathInfo(string assetPath)
+        {
+            AssetPathInfo pathInfo = null;
+            if (!m_dictPathInfo.TryGetValue(assetPath, out pathInfo))
+            {
+                pathInfo = new AssetPathInfo();
+                pathInfo.Path = assetPath;
+                m_dictPathInfo.Add(assetPath, pathInfo);
+            }
+            return pathInfo;
+        }
+
+        private static Dictionary<string, AssetPathInfo> m_dictPathInfo = new Dictionary<string, AssetPathInfo>();
+    }
+}