private static void AddDependenciesInfo(string bundleName, string relativePath, ref DependenciesInfo info, ref ReservedSharedBundleInfo reserved, ref DependencyCache cache) { var dependencies = CollectDependencies(relativePath, ref cache); var deps = dependencies.ToList(); deps.Add(relativePath); foreach (var dependency in deps) { if (!info.ContainsKey(dependency)) { info[dependency] = new DependencyInfo(); } if (IsShader(dependency)) { if (BundlerBuildSettings.kSeparateShaderBundle) { info[dependency].referenceInBundles.Add(BundlerBuildSettings.kSeparatedShaderBundleName); reserved[dependency] = BundlerBuildSettings.kSeparatedShaderBundleName; } } info[dependency].referenceInBundles.Add(bundleName); } }
private static DependenciesInfo ParseBundleDependenciesFromRules(BundlerBuildRule buildRule, ref ReservedSharedBundleInfo reserved, ref DependencyCache cache) { buildRule.rules.Sort((a, b) => - a.shared.CompareTo(b.shared)); var depsInfo = new DependenciesInfo(); foreach (var rule in buildRule.rules) { var packType = (PackType)Enum.Parse(typeof(PackType), rule.packType); switch (packType) { case PackType.PackByFile: ParseBundleDependenciesByRuleOfPackByFile(rule, ref depsInfo, ref reserved, ref cache); break; case PackType.PackByDirectory: ParseBundleDependenciesByRuleOfPackByDirectory(rule, ref depsInfo, ref reserved, ref cache); break; case PackType.PackBySubDirectory: ParseBundleDependenciesByRuleOfPackBySubDirectory(rule, ref depsInfo, ref reserved, ref cache); break; default: throw new ArgumentOutOfRangeException(rule.packType); } } return(depsInfo); }
public static BundlerManifest GenerateManifest(BundlerBuildRule buildRule) { var cache = LoadAssetDependenciesCache(); var reservedSharedBundle = new ReservedSharedBundleInfo(); var depsInfo = ParseBundleDependenciesFromRules(buildRule, ref reservedSharedBundle, ref cache); var bundlesInfo = GenerateBundlesInfo(ref depsInfo, ref reservedSharedBundle, ref cache); ResolveBundleDependencies(ref bundlesInfo, ref cache); //FilterRedundantDependencies(ref bundlesInfo); var manifest = GenerateBundlerManifest(ref bundlesInfo); Resources.UnloadUnusedAssets(); SaveAssetDependenciesCache(cache); return(manifest); }
private static BundlesInfo GenerateBundlesInfo(ref DependenciesInfo depsInfo, ref ReservedSharedBundleInfo reserved, ref DependencyCache cache) { var sharedBundles = ParseSharedBundleInfo(ref depsInfo, ref reserved, ref cache); var noneSharedBundles = ParseNoneSharedBundleInfo(ref depsInfo, ref sharedBundles); var bundles = new BundlesInfo(); sharedBundles.Concat(noneSharedBundles).ToList().ForEach(kv => { if (kv.Value.assets.Count > 0) { bundles.Add(kv.Key, kv.Value); } }); return(bundles); }
private static void ParseBundleDependenciesByRuleOfPackBySubDirectory(BundleRule rule, ref DependenciesInfo depsInfo, ref ReservedSharedBundleInfo reserved, ref DependencyCache cache) { var excludePattern = rule.excludePattern; var searchPath = PathUtility.RelativeProjectPathToAbsolutePath(rule.path); var subDirectories = Directory.GetDirectories(searchPath, "*.*", (SearchOption)rule.depth) .Where(v => !IsExclude(v, excludePattern)) .ToArray(); foreach (var subDirectory in subDirectories) { var files = Directory .GetFiles(subDirectory, rule.searchPattern, SearchOption.AllDirectories) .Where(v => !IsMeta(v)) .Where(v => !IsExclude(v, excludePattern)) .ToArray(); var bundleName = PathUtility.NormalizeAssetBundlePath(subDirectory); bundleName = string.Format(BundlerBuildSettings.kBundleFormatter, bundleName); bundleName = BundlerBuildSettings.kHashAssetBundlePath ? PathUtility.HashPath(bundleName) : bundleName; try { var index = 0; foreach (var file in files) { EditorUtility.DisplayProgressBar("Parsing Rule of Pack By Sub Directory Name", file, (float)index++ / files.Length); var relativePath = PathUtility.AbsolutePathToRelativeProjectPath(file); if (rule.shared) { TryAddToForceSharedBundle(relativePath, bundleName, ref reserved); } AddDependenciesInfo(bundleName, relativePath, ref depsInfo, ref reserved, ref cache); } } finally { EditorUtility.ClearProgressBar(); } } }
private static BundlesInfo ParseSharedBundleInfo(ref DependenciesInfo depsInfo, ref ReservedSharedBundleInfo reserved, ref DependencyCache cache) { var sharedDict = new Dictionary <string, string>(); var index = 0; // Determine shared bundles foreach (var kv in depsInfo) { var asset = kv.Key; // Ignore this asset when forced build in shared bundle. if (reserved.ContainsKey(asset)) { continue; } var depSet = kv.Value; // The count of dependencies no greater than 1 means that there are no other bundles // sharing this asset if (depSet.referenceInBundles.Count <= 1) { continue; } // Otherwise, assets which depended by the same bundles will be separated to shared bundle. if (!sharedDict.ContainsKey(asset)) { sharedDict[asset] = string.Format(BundlerBuildSettings.kSharedBundleFormatter, (++index).ToString()); // Sub-assets dependencies. var deps = CollectDependencies(asset, ref cache); foreach (var dep in deps) { if (reserved.ContainsKey(dep)) { continue; } sharedDict[dep] = string.Format(BundlerBuildSettings.kSharedBundleFormatter, (++index).ToString()); } } } // Collect shared bundles info var bundlesInfo = new BundlesInfo(); foreach (var kv in sharedDict) { var name = sharedDict[kv.Key]; if (bundlesInfo.ContainsKey(name)) { throw new BundleException("Shared bundle duplicated: " + name); } bundlesInfo[name] = new BundleInfo(); bundlesInfo[name].assets.Add(kv.Key); } // Generate unique bundle name according to assets list. var sharedBundle = new BundlesInfo(); foreach (var kv in bundlesInfo) { var assets = kv.Value.assets.ToList(); assets.Sort((a, b) => string.Compare(a, b, StringComparison.Ordinal)); var bundleName = string.Join("-", assets.ToArray()); if (BundlerBuildSettings.kHashSharedBundle) { using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(bundleName))) { var nameHash = CalculateMd5(stream); bundleName = string.Format(BundlerBuildSettings.kSharedBundleFormatter, nameHash); } } else { bundleName = string.Format(BundlerBuildSettings.kSharedBundleFormatter, bundleName.ToLower()); } var bundleInfo = new BundleInfo(); foreach (var asset in kv.Value.assets) { bundleInfo.assets.Add(asset); } sharedBundle.Add(bundleName, bundleInfo); } // Add reserved shared bundles info foreach (var kv in reserved) { var assetName = kv.Key; var bundle = kv.Value; if (!sharedBundle.ContainsKey(bundle)) { sharedBundle.Add(bundle, new BundleInfo()); } sharedBundle[bundle].assets.Add(assetName); } return(sharedBundle); }
private static void TryAddToForceSharedBundle(string assetName, string bundleName, ref ReservedSharedBundleInfo reserved) { if (reserved.ContainsKey(assetName)) { throw new BundleRuleConflictException( string.Format("Asset({0} has already contain in bundle: {1}, but trying add to new bundle: {2})", assetName, reserved[assetName], bundleName)); } reserved.Add(assetName, bundleName); }