static private void BuildAllBundlesClick()
{
if (DevelopUtility.bundleSetting.pathList.Count > 0)
{
if (bundlesInfo == null)
{
bundlesInfo = new BundlesInfo();
}
else
{
bundlesInfo.bundleList.Clear();
}
for (int i = 0; i < DevelopUtility.bundleSetting.pathList.Count; i++)
{
if (DevelopUtility.bundleSetting.pathSelectList[i])
{
string path = Application.dataPath + "/" + DevelopUtility.bundleSetting.pathList[i].Replace("Assets/", "");
GetBundleInfoAt(path);
}
}
BuildAssetBundles();
CreateCV();
CreateBundlesInfo(Application.streamingAssetsPath + "/" + GameUtility.GetPlatformName() + "/" + DevelopUtility.clientConfig.hotfixFile);
}
else
{
Debug.LogError("没有选择任何可执行路径。");
}
}
private void Start()
{
BundlesInfo bundleInfo = new BundlesInfo
{
{ "Cube", new SmartPath()
{
LocalPath = "Bundles/cube_geometry_model", PrefabName = "Cube"
} },
{ "Sphere", new SmartPath()
{
LocalPath = "Bundles/sphere_geometry_model", PrefabName = "Sphere"
} },
{ "Capsule", new SmartPath()
{
LocalPath = "Bundles/capsule_geometry_model", PrefabName = "Capsule"
} }
};
string jsonStr = JsonConvert.SerializeObject(bundleInfo);
byte[] jsonBytes = Encoding.UTF8.GetBytes(jsonStr);
try
{
FileStream fs = new FileStream("geometry_models.json", FileMode.Create);
fs.Write(jsonBytes, 0, jsonBytes.Length);
}
catch (Exception e)
{
Debug.LogError(e.Message);
}
}
private static BundlerManifest GenerateBundlerManifest(ref BundlesInfo bundlesInfo)
{
var manifest = new BundlerManifest();
foreach (var kv in bundlesInfo)
{
var bundleName = kv.Key;
var assets = kv.Value.assets;
var dependencies = kv.Value.dependencies;
// No assets in this bundle, skips.
if (assets.Count <= 0)
{
continue;
}
// Generate assets data
foreach (var asset in assets)
{
if (manifest.assets.ContainsKey(asset))
{
throw new BundleException(string.Format(
"Asset duplicated: {0}, already reference in bundle: {1}, conflict with: {2}",
asset, manifest.assets[asset].bundle, bundleName));
}
var assetData = new AssetData
{
//name = asset, // Memory optimized
bundle = bundleName
};
manifest.assets.Add(asset, assetData);
}
// Generate bundles data
if (manifest.bundles.ContainsKey(bundleName))
{
throw new BundleException(string.Format("Bundle duplicated: {0}", bundleName));
}
//manifest.bundles.Add(bundleName, new BundleData {name = bundleName}); // Memory optimized
manifest.bundles.Add(bundleName, new BundleData {
assets = assets.ToList()
});
foreach (var depName in dependencies)
{
manifest.bundles[bundleName].dependencies.Add(depName);
}
}
foreach (var kv in manifest.bundles)
{
kv.Value.assets.Sort();
kv.Value.dependencies.Sort();
}
return(manifest);
}
static public IEnumerator LoadBundlesInfo(Action <BundlesInfo> callback = null)
{
if (bundlesInfo == null)
{
yield return(LoadFromJson <BundlesInfo> (GameUtility.StreamingHotfixPathFull, "BundlesInfo", (config) => {
bundlesInfo = config;
if (callback != null)
{
callback(bundlesInfo);
}
}));
}
}
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 ResolveBundleDependencies(ref BundlesInfo bundlesInfo, ref DependencyCache cache)
{
var info = bundlesInfo;
var cacheData = cache;
foreach (var kv in bundlesInfo)
{
//Debug.Log(string.Format("Resolving bundle dependency: {0}", kv.Key));
var bundleInfo = kv.Value;
bundleInfo.dependencies.Clear();
void ResolveAssetDependency(string asset)
{
var dependencies = CollectDependencies(asset, ref cacheData);
foreach (var dependencyAsset in dependencies)
{
// Which bundle contains this asset?
var depBundle = info.FirstOrDefault(
v => v.Value.assets.Contains(dependencyAsset)).Key;
if (string.IsNullOrEmpty(depBundle))
{
continue;
}
if (depBundle == kv.Key)
{
continue;
}
if (bundleInfo.dependencies.Contains(depBundle))
{
continue;
}
bundleInfo.dependencies.Add(depBundle);
}
}
foreach (var asset in bundleInfo.assets)
{
ResolveAssetDependency(asset);
}
}
}
private List <string> CollectionRemoteDependence(AssetBundle rootRemoteBundle, Dictionary <string, BundlesInfo> _remoteDependce)
{
AssetBundleManifest rootRemoteManifest = rootRemoteBundle.LoadAsset <AssetBundleManifest>("AssetBundleManifest");
string[] allbundles = rootRemoteManifest.GetAllAssetBundles();
List <string> bundlsList = new List <string>(allbundles);
//Debug.Log("<color=orange>总bundle 数</color> :count of bundlsList::: " + bundlsList.Count);
//Debug.Log(assetbundleName +" || "+ manifest.GetAssetBundleHash(assetbundleName));
//bool iscached = Caching.IsVersionCached(GetPath()+"/iOS/"+assetbundleName, manifest.GetAssetBundleHash(assetbundleName));
//Debug.Log(GetPath() + "/iOS/" + assetbundleName + "<color=red>是否缓存过:</color>" + iscached);
foreach (string remoteBundleName in bundlsList)
{
// 加载依赖
Debug.Log("<color=white>bundle: " + remoteBundleName + "</color>");
var dependenceBundles = rootRemoteManifest.GetAllDependencies(remoteBundleName);
var subDependce = new List <string>(); //每个bundle的子级依赖
//var objs = bundle.LoadAllAssets();
//处理依赖关系
foreach (string dependbundle in dependenceBundles)
{
if (!bundlsList.Contains(dependbundle))
{
// 加载bundle ,其实并没有使用到
Debug.LogError("加载非依赖 <color=green>dependce bundle: " + dependbundle + "</color>");
}
else
{
Debug.Log("<color=yellow>加载子级依赖</color> <color=red> dependce bundle: " + dependbundle + "</color>");
subDependce.Add(dependbundle);
}
}
Hash128 remoteHashcode = rootRemoteManifest.GetAssetBundleHash(remoteBundleName);
BundlesInfo remoteBundleInfo = new BundlesInfo
{
bundlesNames = subDependce,
hashCode = remoteHashcode,
};
_remoteDependce.Add(remoteBundleName, remoteBundleInfo);
}
return(bundlsList);
}
private static BundlesInfo ParseNoneSharedBundleInfo(ref DependenciesInfo depsInfo, ref BundlesInfo sharedBundles)
{
// Parse none shared bundle info
var noneSharedBundles = new BundlesInfo();
foreach (var kv in depsInfo)
{
var assetName = kv.Key;
var bundles = kv.Value.referenceInBundles;
var sharedBundle = sharedBundles.FirstOrDefault(skv => skv.Value.assets.Contains(assetName)).Key ?? "";
foreach (var bundle in bundles)
{
if (!string.IsNullOrEmpty(sharedBundles.FirstOrDefault(skv => skv.Key == bundle).Key))
{
continue; // Equals to shared bundle, pass.
}
if (!noneSharedBundles.ContainsKey(bundle))
{
noneSharedBundles.Add(bundle, new BundleInfo());
}
if (string.IsNullOrEmpty(sharedBundle))
{
noneSharedBundles[bundle].assets.Add(assetName);
}
}
}
// Move *.unity files to independent bundles, because 'Cannot mark assets and scenes in one AssetBundle'
var sceneBundles = new BundlesInfo();
foreach (var kv in noneSharedBundles)
{
var noneSharedAssets = kv.Value.assets;
var removed = new List <string>();
foreach (var asset in noneSharedAssets)
{
if (!asset.EndsWith(".unity"))
{
continue;
}
var sceneBundleName = string.Format(BundlerBuildSettings.kSceneBundleFormatter,
PathUtility.RelativeProjectPathToAbsolutePath(asset));
sceneBundleName = PathUtility.NormalizeAssetBundlePath(sceneBundleName);
if (sceneBundles.ContainsKey(sceneBundleName))
{
throw new BundleException("Scene asset bundle duplicated: " + sceneBundleName);
}
var bundle = new BundleInfo();
bundle.assets.Add(asset);
sceneBundles.Add(sceneBundleName, bundle);
removed.Add(asset);
}
removed.ForEach(v => noneSharedAssets.Remove(v));
}
// Merge to none shared bundles
foreach (var kv in sceneBundles)
{
noneSharedBundles.Add(kv.Key, kv.Value);
}
return(noneSharedBundles);
}
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 FilterRedundantDependencies(ref BundlesInfo bundlesInfo)
{
// Filter out redundant dependencies.
var bsInfo = bundlesInfo;
foreach (var kv in bundlesInfo)
{
var bundleInfo = kv.Value;
bool IsDependencyInBundle(string bundleName, BundleInfo bInfo)
{
foreach (var dependency in bInfo.dependencies)
{
if (dependency == bundleName)
{
return(true);
}
if (!bsInfo.ContainsKey(dependency))
{
continue;
}
if (IsDependencyInBundle(bundleName, bsInfo[dependency]))
{
return(true);
}
}
return(false);
}
bool IsReferenceInDependencies(string toCheck, BundleInfo bInfo)
{
//Debug.Log(string.Format("Checking dependency: {0}", toCheck));
foreach (var dependency in bInfo.dependencies)
{
if (dependency == toCheck)
{
continue;
}
if (!bsInfo.ContainsKey(dependency))
{
continue;
}
if (IsDependencyInBundle(toCheck, bsInfo[dependency]))
{
return(true);
}
}
return(false);
}
//Debug.Log(string.Format("Checking redundant dependency: {0}", kv.Key));
var toRemove = new List <string>();
foreach (var dependency in bundleInfo.dependencies)
{
if (IsReferenceInDependencies(dependency, bundleInfo))
{
toRemove.Add(dependency);
}
}
toRemove.ForEach(v => {
//Debug.Log(string.Format("Dependency redundant, removed: {0}, in bundle: {1}", v, kv.Key));
bundleInfo.dependencies.Remove(v);
});
}
}
