private ReferenceNode SearchSpriteAtlas( Object unityObject )
{
SpriteAtlas spriteAtlas = (SpriteAtlas) unityObject;
ReferenceNode referenceNode = PopReferenceNode( spriteAtlas );
SerializedObject spriteAtlasSO = new SerializedObject( spriteAtlas );
if( spriteAtlas.isVariant )
{
Object masterAtlas = spriteAtlasSO.FindProperty( "m_MasterAtlas" ).objectReferenceValue;
if( objectsToSearchSet.Contains( masterAtlas ) )
referenceNode.AddLinkTo( SearchObject( masterAtlas ), "Master Atlas" );
}
#if UNITY_2018_2_OR_NEWER
Object[] packables = spriteAtlas.GetPackables();
if( packables != null )
{
for( int i = 0; i < packables.Length; i++ )
referenceNode.AddLinkTo( SearchObject( packables[i] ), "Packed Texture" );
}
#else
SerializedProperty packables = spriteAtlasSO.FindProperty( "m_EditorData.packables" );
if( packables != null )
{
for( int i = 0, length = packables.arraySize; i < length; i++ )
referenceNode.AddLinkTo( SearchObject( packables.GetArrayElementAtIndex( i ).objectReferenceValue ), "Packed Texture" );
}
#endif
return referenceNode;
}
/// <summary>
/// 查找Atlas引用的所有的资源
/// </summary>
/// <param name="atlas"></param>
/// <returns></returns>
public static string[] GetDependAssets(SpriteAtlas atlas)
{
if (atlas == null)
{
return(null);
}
List <string> spriteAssetPathList = new List <string>();
UnityObject[] objs = atlas.GetPackables();
foreach (var obj in objs)
{
if (obj.GetType() == typeof(Sprite))
{
spriteAssetPathList.Add(AssetDatabase.GetAssetPath(obj));
}
else if (obj.GetType() == typeof(DefaultAsset))//如果是文件夹
{
string folderPath = AssetDatabase.GetAssetPath(obj);
string[] assets = AssetDatabaseUtil.FindAssetInFolder <Sprite>(folderPath);
spriteAssetPathList.AddRange(assets);
}
}
return(spriteAssetPathList.Distinct().ToArray());
}
/// <summary>
/// 由于UGUI中SpriteAtlas的特殊性，为了防止UI的Prefab打包无法与Atlas关联，
/// 从而设定将SpriteAtlas所使用的Sprite一起打包
/// </summary>
/// <param name="atlasAssetPath">SpriteAtlas所在的资源路径</param>
/// <param name="bundlePath">需要设置的BundleName</param>
private static void SetSpriteBundleNameByAtlas(string atlasAssetPath, string bundlePath)
{
SpriteAtlas atlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(atlasAssetPath);
if (atlas != null)
{
List <string> spriteAssetPathList = new List <string>();
UnityObject[] objs = atlas.GetPackables();
foreach (var obj in objs)
{
if (obj.GetType() == typeof(Sprite))
{
spriteAssetPathList.Add(AssetDatabase.GetAssetPath(obj));
}
else if (obj.GetType() == typeof(DefaultAsset))
{
string folderPath = AssetDatabase.GetAssetPath(obj);
string[] assets = AssetDatabaseUtil.FindAssetInFolder <Sprite>(folderPath);
spriteAssetPathList.AddRange(assets);
}
}
spriteAssetPathList.Distinct();
foreach (var path in spriteAssetPathList)
{
AssetImporter ai = AssetImporter.GetAtPath(path);
ai.assetBundleName = bundlePath;
}
}
}
static void ResetAtlas(SpriteAtlas atlas, Object[] objects)
{
var oldSprites = atlas.GetPackables();
atlas.Remove(oldSprites);
atlas.Add(objects);
}
public static Dictionary <string, string> CollectionAssetPathToBundleNames()
{
Dictionary <string, string> pathToNames = new Dictionary <string, string>();
pathToNames[AssetAddressConfig.CONFIG_PATH] = AssetAddressConfig.CONFIG_ASSET_BUNDLE_NAME.ToLower();
#region Collection
AssetBundleTagConfig tagConfig = Util.FileUtil.ReadFromBinary <AssetBundleTagConfig>(BundlePackUtil.GetTagConfigPath());
AssetAddressData[] datas = (from groupData in tagConfig.GroupDatas
from detailData in groupData.AssetDatas
select detailData).ToArray();
long elapsedMS = Leyoutech.Utility.DebugUtility.GetMillisecondsSinceStartup();
for (int iData = 0; iData < datas.Length; iData++)
{
AssetAddressData iterData = datas[iData];
string assetPath = iterData.AssetPath;
string bundleName = iterData.BundlePath.ToLower();
pathToNames[assetPath] = bundleName;
if (Path.GetExtension(assetPath).ToLower() != ".spriteatlas")
{
continue;
}
SpriteAtlas atlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(assetPath);
if (atlas == null)
{
continue;
}
UnityObject[] packables = atlas.GetPackables();
for (int iPackable = 0; iPackable < packables.Length; iPackable++)
{
UnityObject iterPackable = packables[iPackable];
if (iterPackable.GetType() == typeof(Sprite))
{
pathToNames[AssetDatabase.GetAssetPath(iterPackable)] = bundleName;
}
else if (iterPackable.GetType() == typeof(DefaultAsset))
{
string folderPath = AssetDatabase.GetAssetPath(iterPackable);
string[] assets = AssetDatabaseUtil.FindAssetInFolder <Sprite>(folderPath);
for (int iAsset = 0; iAsset < assets.Length; iAsset++)
{
pathToNames[assets[iAsset]] = bundleName;
}
}
}
}
elapsedMS = Leyoutech.Utility.DebugUtility.GetMillisecondsSinceStartup() - elapsedMS;
Leyoutech.Utility.DebugUtility.Log(Leyoutech.BuildPipeline.BuildPipelineGraph.LOG_TAG, $"Collection all bundleName count ({pathToNames.Count}) elapsed {Leyoutech.Utility.DebugUtility.FormatMilliseconds(elapsedMS)}");
#endregion
return(pathToNames);
}
public static void Clear(this SpriteAtlas atlas)
{
var packedObjects = atlas.GetPackables();
var removedCount = 0;
for (var i = 0; i < packedObjects.Length; i++)
{
atlas.RemoveAt(i - removedCount);
removedCount++;
}
}
public static bool DeleteEmptyAtlas(SpriteAtlas atlas)
{
var packables = atlas.GetPackables();
if (packables.Length != 0 || AtlasGeneratorSettings.Asset.deleteEmptyAtlas == false)
{
return(false);
}
var path = AssetDatabase.GetAssetPath(atlas);
AtlasGeneratorSettings.Asset.generatedAtlases.RemoveAll(atlasPath => atlasPath == path);
EditorUtility.SetDirty(AtlasGeneratorSettings.Asset);
AssetDatabase.DeleteAsset(path);
return(true);
}
private void TrySetupSpriteAtlas()
{
if (_atlas == null)
{
return;
}
Object[] atPath = AssetDatabase.LoadAllAssetsAtPath(assetPath);
Sprite[] sprites = atPath.Where(p => p is Sprite).Cast <Sprite>().ToArray();
//remove existing
_atlas.Remove(_atlas.GetPackables());
//add sorted sprites
Object[] inputSprites = sprites.Distinct().OrderBy(p => p.name).Cast <Object>().ToArray();
_atlas.Add(inputSprites);
}
private void TryCloneSpriteAtlas()
{
SpriteAtlas atlas = _importer.Atlas;
if (!atlas)
{
return;
}
//clone the sprite atlas asset
SpriteAtlas newAtlas = CloneArtifact(atlas, "/Sprites");
//clear, then re-fill the atlas with used sprites
newAtlas.Remove(newAtlas.GetPackables());
//add art tiles
Object[] objects = _artTileSprites.OrderBy(p => p.name).Cast <Object>().ToArray();
newAtlas.Add(objects);
//pack
SpriteAtlasUtility.PackAtlases(new [] { newAtlas }, EditorUserBuildSettings.activeBuildTarget);
}
void GetSpriteAssetitem(string atlasAssetPath, ref List <string> spriteAssetPathList)
{
SpriteAtlas atlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(atlasAssetPath);
if (atlas != null)
{
UnityObject[] objs = atlas.GetPackables();
foreach (var obj in objs)
{
if (obj.GetType() == typeof(Sprite))
{
spriteAssetPathList.Add(AssetDatabase.GetAssetPath(obj));
}
else if (obj.GetType() == typeof(DefaultAsset))
{
string folderPath = AssetDatabase.GetAssetPath(obj);
string[] assets = AssetDatabaseUtil.FindAssetInFolder <Sprite>(folderPath);
spriteAssetPathList.AddRange(assets);
}
}
spriteAssetPathList.Distinct();
}
}
static public bool SetBundleName(string directory, string name, string variant, string[] ignores, bool separateFile, bool separateSubFolder, out string err)
{
err = string.Empty;
string[] files = Directory.GetFiles(directory);
string[] subFolders = Directory.GetDirectories(directory);
bool hasSubFolders = subFolders.Length > 0 && separateSubFolder;
// handle files
for (int i = 0; i < files.Length; i++)
{
string ext = Path.GetExtension(files[i]);
if (".meta".Equals(ext) || ".cs".Equals(ext) || ".js".Equals(ext) || ".DS_Store".Equals(ext))
{
continue;
}
string fileName = Path.GetFileName(files[i]);
if (fileName.StartsWith(".", System.StringComparison.Ordinal))
{
continue;
}
if (CheckIgnored(fileName, ignores))
{
continue;
}
AssetImporter importer = AssetImporter.GetAtPath(files[i]);
if (importer == null)
{
Debug.LogError(files[i]);
err = files[i];
return(false);
}
string assetBundleName = string.Empty;
if (separateFile || hasSubFolders)
{
assetBundleName = name + "/" + Path.GetFileNameWithoutExtension(files[i]);
}
else
{
assetBundleName = name;
}
assetBundleName = assetBundleName.ToLower();
variant = variant.ToLower();
if (!importer.assetBundleName.Equals(assetBundleName))
{
importer.assetBundleName = assetBundleName;
}
if (!importer.assetBundleVariant.Equals(variant))
{
importer.assetBundleVariant = variant;
}
#if UNITY_PS4
if (assetBundleName.Split('/').Length >= 7)
{
Debug.LogErrorFormat("{0}: folder depth exceeds the limit", assetBundleName);
}
#endif
if (!Application.isBatchMode && EditorUtility.DisplayCancelableProgressBar("Set: " + assetBundleName, files[i], 1f * i / files.Length))
{
err = "User Canceled";
return(false);
}
// handle spriteatlas ref folder
if (".spriteatlas".Equals(ext))
{
SpriteAtlas atlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(files[i]);
Object[] objs = atlas.GetPackables();
foreach (Object obj in objs)
{
string objPath = AssetDatabase.GetAssetPath(obj);
if (Directory.Exists(objPath))
{
AssetImporter imp = AssetImporter.GetAtPath(objPath);
if (!imp.assetBundleName.Equals(assetBundleName))
{
imp.assetBundleName = assetBundleName;
}
if (!imp.assetBundleVariant.Equals(variant))
{
imp.assetBundleVariant = variant;
}
if (!SetBundleName(objPath, assetBundleName, variant, ignores, false, false, out err))
{
return(false);
}
}
else
{
AssetImporter imp = AssetImporter.GetAtPath(objPath);
if (imp != null)
{
if (!imp.assetBundleName.Equals(assetBundleName))
{
imp.assetBundleName = assetBundleName;
}
if (!imp.assetBundleVariant.Equals(variant))
{
imp.assetBundleVariant = variant;
}
}
}
}
}
}
// handle sub folders
for (int i = 0; i < subFolders.Length; i++)
{
if (subFolders[i].Contains(".DS_Store"))
{
continue;
}
if (CheckIgnored(subFolders[i], ignores))
{
continue;
}
if (separateSubFolder)
{
if (!SetBundleName(subFolders[i], name + subFolders[i].Replace(directory, "").ToLower(), variant, ignores, separateFile, separateSubFolder, out err))
{
return(false);
}
}
else
{
if (!SetBundleName(subFolders[i], name, variant, ignores, separateFile, separateSubFolder, out err))
{
return(false);
}
}
}
return(true);
}
private static void PackedAuto()
{
string uipath = Application.dataPath + "/UI/";
SpriteAtlasPackingSettings setting = new SpriteAtlasPackingSettings();
setting.enableRotation = false;
setting.enableTightPacking = false;
//SpriteAtlasTextureSettings texSetting = new SpriteAtlasTextureSettings();
TextureImporterPlatformSettings texPlatSetting = new TextureImporterPlatformSettings();
texPlatSetting.maxTextureSize = 2048;
texPlatSetting.crunchedCompression = true;
texPlatSetting.compressionQuality = 100;
string[] dirs = Directory.GetDirectories(uipath);
foreach (string dir in dirs)
{
string folderName = dir.Replace(uipath, "");
string sourcePath = dir.Replace(Application.dataPath, "Assets");
string[] guids = AssetDatabase.FindAssets("t:Sprite", new string[] { sourcePath });
if (guids.Length > 0)
{
List <Sprite> listSpite = new List <Sprite>();
foreach (string guid in guids)
{
Sprite s = AssetDatabase.LoadAssetAtPath <Sprite>(AssetDatabase.GUIDToAssetPath(guid)) as Sprite;
listSpite.Add(s);
}
string dest = string.Format("Assets/UIAtlas/{0}.spriteatlas", folderName.ToLower());
SpriteAtlas atlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(dest);
if (atlas)
{
SpriteAtlasExtensions.Remove(atlas, atlas.GetPackables());
}
else
{
atlas = new SpriteAtlas();
atlas.SetPackingSettings(setting);
atlas.SetPlatformSettings(texPlatSetting);
AssetDatabase.CreateAsset(atlas, dest);
}
SpriteAtlasExtensions.Add(atlas, listSpite.ToArray());
EditorUtility.SetDirty(atlas);
}
}
EditorUtility.DisplayDialog("提示", "创建图集成功", "确认");
//ICON ATLAS 重icon collection來
//找 iconid to sprite collection
/*string[] iconcollectons = AssetDatabase.FindAssets("t:IconIdToSpriteCollection", new string[]{ "Assets/MainAssets/IconCollection/Auto"});
* foreach (var collectionGuid in iconcollectons)
* {
* IconIdToSpriteCollection iconCollection = AssetDatabase.LoadAssetAtPath<IconIdToSpriteCollection>(AssetDatabase.GUIDToAssetPath(collectionGuid));
*
* if (iconcollectons != null)
* {
* string dest = string.Format("Assets/MainAssets/ArtAssets/BundleAssets/IconCollectionAtlas/atlas_iconcollection_{0}.spriteatlas", iconCollection.name.ToLower());
* SpriteAtlas atlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(dest);
* if (atlas)
* {
* SpriteAtlasExtensions.Remove(atlas, atlas.GetPackables());
* }
* else
* {
* atlas = new SpriteAtlas();
* atlas.SetPackingSettings(setting);
* AssetDatabase.CreateAsset(atlas, dest);
* }
*
* Object[] t = iconCollection.GetAllSprites().ToArray();
* SpriteAtlasExtensions.Add(atlas, t);
*
*
* EditorUtility.SetDirty(atlas);
* }
* }*/
AssetDatabase.SaveAssets();
}
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
{
for (int i = 0; i < importedAssets.Length; i++)
{
string assetPath = importedAssets[i].Replace("\\", "/");
if (!assetPath.StartsWith("Assets/Localization/") && !assetPath.StartsWith("Assets/Res/"))
{
continue;
}
if (!AssetDatabase.IsValidFolder(assetPath))
{
continue; //非文件夹文件
}
DirectoryInfo dirAssetInfo = new DirectoryInfo(assetPath);
for (int j = 0; j < _atlasRuleDir.Length; j++)
{
AtlasInfo atlasInfo_Rule = _atlasRuleDir[j];
if (!assetPath.Equals(atlasInfo_Rule.dir) && !assetPath.StartsWith(atlasInfo_Rule.dir + "/"))
{
continue;
}
//命中目标文件夹
if (dirAssetInfo.Parent.FullName.Equals(atlasInfo_Rule.fullName))
{
FileInfo[] atlasFiles = dirAssetInfo.GetFiles("*.spriteatlas", SearchOption.AllDirectories);
FileInfo targetAtlas = null; //文件夹下直属Atlas
for (int k = 0; k < atlasFiles.Length; k++)
{
FileInfo file = atlasFiles[k];
if (targetAtlas == null)
{
if (file.Directory.FullName.Equals(dirAssetInfo.FullName))
{
targetAtlas = file;
}
}
else
{
file.Delete(); //删除其他的Atlas
}
}
string targetName = atlasInfo_Rule.prefix_name + "_" + dirAssetInfo.Name + "_Atlas.spriteatlas";
if (targetAtlas == null) //没有找到直属Atlas
{
AssetDatabase.CreateAsset(new SpriteAtlas(), assetPath + "/" + targetName);
targetAtlas = new FileInfo(dirAssetInfo.FullName + "/" + targetName);
}
else
{
AssetDatabase.RenameAsset(assetPath + "/" + targetAtlas.Name, targetName); //改名
targetAtlas = new FileInfo(dirAssetInfo.FullName + "/" + targetName);
}
//对Atlas进行设置
SpriteAtlas atlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(assetPath + "/" + targetAtlas.Name);
SpriteAtlasPackingSettings packingSettings = atlas.GetPackingSettings();
packingSettings.enableRotation = atlasInfo_Rule.isRotation;
packingSettings.enableTightPacking = atlasInfo_Rule.isTight;
packingSettings.padding = 2;
atlas.SetPackingSettings(packingSettings);
TextureImporterPlatformSettings platformSettings = atlas.GetPlatformSettings("iPhone");
platformSettings.overridden = true;
if (platformSettings.maxTextureSize > 2048)
{
platformSettings.maxTextureSize = 2048;
}
platformSettings.format = TextureImporterFormat.ASTC_RGBA_6x6;
atlas.SetPlatformSettings(platformSettings);
atlas.Remove(atlas.GetPackables());
atlas.Add(new [] { AssetDatabase.LoadAssetAtPath <Object>(assetPath) });
}
break;
}
}
}