public override void OnPostprocessAllAssets(IAkyuiLoader loader, Object[] importAssets)
{
var spriteAtlasPath = spriteAtlasOutputPath.Replace("{name}", loader.LayoutInfo.Name) + ".spriteatlas";
var spriteAtlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(spriteAtlasPath);
if (spriteAtlas == null)
{
Debug.Log($"Create SpriteAtlas: {spriteAtlasPath}");
AkyuiEditorUtil.CreateDirectory(Path.GetDirectoryName(spriteAtlasPath));
spriteAtlas = new SpriteAtlas();
AssetDatabase.CreateAsset(spriteAtlas, spriteAtlasPath);
}
if (source != null)
{
EditorUtility.CopySerialized(source, spriteAtlas);
}
spriteAtlas.name = loader.LayoutInfo.Name;
spriteAtlas.Remove(spriteAtlas.GetPackables());
spriteAtlas.Add(importAssets);
SpriteAtlasUtility.PackAtlases(new[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget);
}
protected override void OnUpdate()
{
SpriteAtlasUtility.PackAllAtlases(UnityEditor.BuildTarget.StandaloneWindows);
Entities.ForEach((UnityEngine.Sprite sprite) =>
DeclareReferencedAsset(sprite.texture));
}
string CreateSpriteAtlasWithSprite()
{
// create a Sprite atlas, + sprite
var spriteAtlasPath = GetAssetPath("testAtlas.spriteatlas");
SpriteAtlas spriteAtlas = new SpriteAtlas();
AssetDatabase.CreateAsset(spriteAtlas, spriteAtlasPath);
Texture2D texture = Texture2D.whiteTexture;
byte[] data = texture.EncodeToPNG();
var texturePath = GetAssetPath("testTexture.png");
File.WriteAllBytes(texturePath, data);
AssetDatabase.ImportAsset(texturePath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
TextureImporter importer = TextureImporter.GetAtPath(texturePath) as TextureImporter;
importer.textureType = TextureImporterType.Sprite;
importer.spriteImportMode = SpriteImportMode.Single;
importer.SaveAndReimport();
SpriteAtlasExtensions.Add(spriteAtlas, new[] { AssetDatabase.LoadAssetAtPath <Texture>(texturePath) });
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget, false);
return(spriteAtlasPath);
}
protected override void OnInit()
{
var mainSO = ScriptableObject.CreateInstance <TestObject>();
var subSO = ScriptableObject.CreateInstance <TestSubObject>();
subSO.name = "sub";
m_ScriptableObjectPath = Path.Combine(k_TestConfigFolder, "testScriptableObject.asset");
AssetDatabase.CreateAsset(mainSO, m_ScriptableObjectPath);
AssetDatabase.AddObjectToAsset(subSO, m_ScriptableObjectPath);
AssetDatabase.ImportAsset(m_ScriptableObjectPath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
// create a Sprite atlas, + sprite
m_SpriteAtlasPath = Path.Combine(k_TestConfigFolder, "testAtlas.spriteatlas");
SpriteAtlas spriteAtlas = new SpriteAtlas();
AssetDatabase.CreateAsset(spriteAtlas, m_SpriteAtlasPath);
Texture2D texture = Texture2D.whiteTexture;
byte[] data = texture.EncodeToPNG();
m_TexturePath = Path.Combine(k_TestConfigFolder, "testTexture.png");
File.WriteAllBytes(m_TexturePath, data);
AssetDatabase.ImportAsset(m_TexturePath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
TextureImporter importer = TextureImporter.GetAtPath(m_TexturePath) as TextureImporter;
importer.textureType = TextureImporterType.Sprite;
importer.spriteImportMode = SpriteImportMode.Single;
importer.SaveAndReimport();
SpriteAtlasExtensions.Add(spriteAtlas, new [] { AssetDatabase.LoadAssetAtPath <Texture>(m_TexturePath) });
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget, false);
}
public override void OnPostprocessAllAssets(IAkyuiLoader loader, Object[] importAssets)
{
var spriteAtlasPath = spriteAtlasOutputPath.Replace("{name}", loader.LayoutInfo.Name) + ".spriteatlas";
var spriteAtlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(spriteAtlasPath);
if (spriteAtlas == null)
{
Debug.Log($"Create SpriteAtlas: {spriteAtlasPath}");
AkyuiEditorUtil.CreateDirectory(Path.GetDirectoryName(spriteAtlasPath));
spriteAtlas = new SpriteAtlas();
AssetDatabase.CreateAsset(spriteAtlas, spriteAtlasPath);
}
if (spriteAtlasPreset != null)
{
spriteAtlasPreset.ApplyTo(spriteAtlas);
}
spriteAtlas.name = loader.LayoutInfo.Name;
spriteAtlas.Remove(spriteAtlas.GetPackables());
spriteAtlas.Add(importAssets);
SpriteAtlasUtility.PackAtlases(new[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget);
// なにかのバグだと思うんだけど、ここでSaveしないとPresetが反映されないことがある Unity 2020.3.18
EditorUtility.SetDirty(spriteAtlas);
AssetDatabase.SaveAssets();
}
public void Process()
{
if (!HasData)
{
return;
}
foreach (var sceneData in _applicationSpritesData.Data)
{
if (sceneData.Sprites.Count > 0)
{
MoveSprites(sceneData.SceneName, sceneData.Sprites);
#if UNITY_2017_1_OR_NEWER
CreateAtlas(sceneData.SceneName);
#endif
}
}
CreateCommonAtlas(_applicationSpritesData.CommonSprites);
AssetDatabase.Refresh();
#if UNITY_2017_1_OR_NEWER
SpriteAtlasUtility.PackAllAtlases(EditorUserBuildSettings.activeBuildTarget);
#endif
}
public void WhenSpriteWithAtlas_SpriteImportDataCreated(SpritePackerMode spriteMode, string spritePackingTag, bool hasReferencingSpriteAtlas, bool expectedPacked)
{
string sourceTexture = Path.Combine(kSourceTestAssetFolder, "SpriteTexture32x32.png");
string destTexture = Path.Combine(kTestAssetFolder, "SpriteTexture32x32.png");
AssetDatabase.CopyAsset(sourceTexture, destTexture);
TextureImporter importer = AssetImporter.GetAtPath(destTexture) as TextureImporter;
importer.spritePackingTag = spritePackingTag;
importer.SaveAndReimport();
if (hasReferencingSpriteAtlas)
{
var sa = new SpriteAtlas();
var targetObjects = new UnityEngine.Object[] { AssetDatabase.LoadAssetAtPath <Texture>(destTexture) };
sa.Add(targetObjects);
string saPath = Path.Combine(kTestAssetFolder, "sa.spriteAtlas");
AssetDatabase.CreateAsset(sa, saPath);
AssetDatabase.Refresh();
}
GUID.TryParse(AssetDatabase.AssetPathToGUID(destTexture), out GUID spriteGUID);
CalculateAssetDependencyData.TaskInput input = CreateDefaultInput();
EditorSettings.spritePackerMode = spriteMode;
SpriteAtlasUtility.PackAllAtlases(input.Target);
input.Assets = new List <GUID>()
{
spriteGUID
};
CalculateAssetDependencyData.RunInternal(input, out CalculateAssetDependencyData.TaskOutput output);
Assert.AreEqual(expectedPacked, output.AssetResults[0].spriteData.PackedSprite);
}
#pragma warning restore 649
public ReturnCode Run()
{
// TODO: Need a return value if this ever can fail
Packer.RebuildAtlasCacheIfNeeded(m_Parameters.Target, true, Packer.Execution.Normal);
SpriteAtlasUtility.PackAllAtlases(m_Parameters.Target);
return(ReturnCode.Success);
}
static void CreateFolderEntryAssets(string RootFolder, AddressableAssetSettings settings, AddressableAssetGroup group)
{
AssetDatabase.CreateFolder(RootFolder, "folderEntry");
string folderPath = RootFolder + "/folderEntry";
{
var texture = new Texture2D(32, 32);
var data = ImageConversion.EncodeToPNG(texture);
UnityEngine.Object.DestroyImmediate(texture);
AssetDatabase.GenerateUniqueAssetPath(RootFolder);
var spritePath = folderPath + "/spritesheet.png";
File.WriteAllBytes(spritePath, data);
AssetDatabase.ImportAsset(spritePath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
var spriteGuid = AssetDatabase.AssetPathToGUID(spritePath);
var importer = (TextureImporter)AssetImporter.GetAtPath(spritePath);
importer.textureType = TextureImporterType.Sprite;
importer.spriteImportMode = SpriteImportMode.Multiple;
importer.spritesheet = new SpriteMetaData[] { new SpriteMetaData()
{
name = "topleft", pivot = Vector2.zero, rect = new Rect(0, 0, 16, 16)
},
new SpriteMetaData()
{
name = "botright", pivot = Vector2.zero, rect = new Rect(16, 16, 16, 16)
} };
importer.SaveAndReimport();
}
{
var texture = new Texture2D(32, 32);
var data = ImageConversion.EncodeToPNG(texture);
UnityEngine.Object.DestroyImmediate(texture);
var spritePath = folderPath + "/sprite.png";
File.WriteAllBytes(spritePath, data);
AssetDatabase.ImportAsset(spritePath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
var spriteGuid = AssetDatabase.AssetPathToGUID(spritePath);
var importer = (TextureImporter)AssetImporter.GetAtPath(spritePath);
importer.textureType = TextureImporterType.Sprite;
importer.SaveAndReimport();
string atlasPath = folderPath + "/atlas.spriteatlas";
var sa = new SpriteAtlas();
AssetDatabase.CreateAsset(sa, atlasPath);
sa.Add(new UnityEngine.Object[]
{
AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(AssetDatabase.GUIDToAssetPath(spriteGuid))
});
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { sa }, EditorUserBuildSettings.activeBuildTarget, false);
}
var folderEntry = settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(folderPath), group, false, false);
folderEntry.address = "folderEntry";
}
public static void GenSpriteAtlas()
{
var addressGroupConfig = AssetDatabase.LoadAssetAtPath <BundleGroups>(BundleGroupConfigPath);
if (addressGroupConfig)
{
var atlasItems = addressGroupConfig.SpriteAtlasItems;
EditorUtility.DisplayProgressBar("图集", "生成图集中", 0);
List <string> spriteAtlasKeys = new List <string>();
foreach (var item in atlasItems)
{
var assets = item.GetAllAssets();
foreach (var path in assets)
{
var atlasFileName = path + ".spriteatlas";
if (Directory.GetDirectories(path).Length == 0)
{
if (!File.Exists(atlasFileName))
{
var obj = AssetDatabase.LoadMainAssetAtPath(path);
if (obj)
{
SpriteAtlas spriteAtlas = new SpriteAtlas();
spriteAtlas.Add(new UnityEngine.Object[] { obj });
AssetDatabase.CreateAsset(spriteAtlas, atlasFileName);
}
}
}
var atlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(atlasFileName);
if (atlas)
{
if (!spriteAtlasKeys.Contains(atlasFileName))
{
spriteAtlasKeys.Add(atlasFileName);
}
else
{
Debug.LogError("重复的图集名称，解决办法：文件夹名字不重复，即使在不同的文件夹！");
}
atlas.SetIncludeInBuild(false);
SpriteAtlasPackingSettings settings = SpriteAtlasExtensions.GetPackingSettings(atlas);
settings.enableTightPacking = false;
settings.enableRotation = false;
settings.padding = 2;
SpriteAtlasExtensions.SetPackingSettings(atlas, settings);
}
}
}
EditorUtility.DisplayProgressBar("图集", "Packing sprite atlas", 0.7f);
SpriteAtlasUtility.PackAllAtlases(EditorUserBuildSettings.activeBuildTarget);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
EditorUtility.ClearProgressBar();
}
}
#pragma warning restore 649
/// <inheritdoc />
public ReturnCode Run()
{
// TODO: Need a return value if this ever can fail
#if !UNITY_2020_1_OR_NEWER
Packer.RebuildAtlasCacheIfNeeded(m_Parameters.Target, true, Packer.Execution.Normal);
#endif
SpriteAtlasUtility.PackAllAtlases(m_Parameters.Target);
return ReturnCode.Success;
}
public SpriteAtlas SetUpSpriteAtlas(int numAtlasObjects, out List <Object> subAssets)
{
// Setup Sprite data
var texture = new Texture2D(32, 32);
var data = ImageConversion.EncodeToPNG(texture);
UnityEngine.Object.DestroyImmediate(texture);
// Setup Sprites
subAssets = new List <Object>();
Directory.CreateDirectory(ConfigFolder + "/test");
var atlasPath = ConfigFolder + "/test" + "/testAtlas.spriteatlas";
var newAtlas = new SpriteAtlas();
var sprites = new Object[numAtlasObjects];
for (int i = 0; i < numAtlasObjects; i++)
{
// Create Sprite asset
AssetDatabase.GenerateUniqueAssetPath(ConfigFolder);
var newSpritePath = ConfigFolder + "/test" + "/testSprite" + i + ".png";
File.WriteAllBytes(newSpritePath, data);
AssetDatabase.ImportAsset(newSpritePath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
var importer = (TextureImporter)AssetImporter.GetAtPath(newSpritePath);
importer.textureType = TextureImporterType.Sprite;
importer.spriteImportMode = SpriteImportMode.Multiple;
importer.spritesheet = new SpriteMetaData[] { new SpriteMetaData()
{
name = "topleft", pivot = Vector2.zero, rect = new Rect(0, 0, 16, 16)
},
new SpriteMetaData()
{
name = "testSprite" + i, pivot = Vector2.zero, rect = new Rect(16, 16, 16, 16)
} };
importer.SaveAndReimport();
// Add sprite to subassets
Object spr = AssetDatabase.LoadAssetAtPath(newSpritePath, typeof(Sprite));
spr.name = "testSprite" + i;
sprites[i] = spr;
subAssets.Add(spr);
}
// Setup Atlas
newAtlas.Add(sprites);
AssetDatabase.CreateAsset(newAtlas, atlasPath);
AssetDatabase.Refresh();
SpriteAtlasExtensions.Add(newAtlas, sprites);
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { newAtlas }, EditorUserBuildSettings.activeBuildTarget, false);
var atlasGuid = AssetDatabase.AssetPathToGUID(atlasPath);
Settings.CreateOrMoveEntry(atlasGuid, Settings.groups[0]);
return(newAtlas);
}
protected string CreateSpriteAtlas(string atlasPath, string[] spriteTextureGuids)
{
var sa = new SpriteAtlas();
AssetDatabase.CreateAsset(sa, atlasPath);
Object[] targetObjects = spriteTextureGuids.Select(g => AssetDatabase.LoadAssetAtPath <Object>(AssetDatabase.GUIDToAssetPath(g))).ToArray();
sa.Add(targetObjects);
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { sa }, EditorUserBuildSettings.activeBuildTarget, false);
AssetDatabase.Refresh();
return(AssetDatabase.AssetPathToGUID(atlasPath));
}
public void Order(Customer customer, Floor floor, Food orderedFood)
{
OrderedFood = orderedFood;
previewRenderer.sprite = SpriteAtlasUtility.GetSprite("Atlas/FoodAtlas", orderedFood.FoodData.spritePath);
Customer = customer;
Floor = floor;
Floor.GetComponent <BusinessSystem>().AddOrderSheet(this);
ChangeState(OerderState.Waiting);
}
public static string[] Export(SpriteAtlas atlas, string dirPath)
{
string platformName = "Standalone";
if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.Android)
{
platformName = "Android";
}
else if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.iOS)
{
platformName = "iPhone";
}
TextureImporterPlatformSettings tips = atlas.GetPlatformSettings(platformName);
TextureImporterPlatformSettings cachedTips = new TextureImporterPlatformSettings();
tips.CopyTo(cachedTips);
tips.overridden = true;
tips.format = TextureImporterFormat.RGBA32;
//tips.maxTextureSize = 1024;
atlas.SetPlatformSettings(tips);
List <string> texturePathList = new List <string>();
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { atlas }, EditorUserBuildSettings.activeBuildTarget);
MethodInfo getPreviewTextureMI = typeof(SpriteAtlasExtensions).GetMethod("GetPreviewTextures", BindingFlags.Static | BindingFlags.NonPublic);
Texture2D[] atlasTextures = (Texture2D[])getPreviewTextureMI.Invoke(null, new SystemObject[] { atlas });
if (atlasTextures != null && atlasTextures.Length > 0)
{
for (int i = 0; i < atlasTextures.Length; i++)
{
Texture2D packTexture = atlasTextures[i];
byte[] rawBytes = packTexture.GetRawTextureData();
Texture2D nTexture = new Texture2D(packTexture.width, packTexture.height, packTexture.format, false, false);
nTexture.LoadRawTextureData(rawBytes);
nTexture.Apply();
string textPath = string.Format("{0}/{1}_{2}.png", dirPath, atlas.name, i);
File.WriteAllBytes(textPath, nTexture.EncodeToPNG());
texturePathList.Add(textPath);
}
}
atlas.SetPlatformSettings(cachedTips);
return(texturePathList.ToArray());
}
void CreateSpriteAtlas(string path, string[] spriteAssetPaths)
{
var sa = new SpriteAtlas();
AssetDatabase.CreateAsset(sa, path);
foreach (string spritePath in spriteAssetPaths)
{
sa.Add(new UnityEngine.Object[]
{
AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(spritePath)
});
}
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { sa }, EditorUserBuildSettings.activeBuildTarget, false);
}
public override void Export()
{
#if USE_SPRITEATLAS
SpriteAtlasUtility.PackAllAtlases(EditorUserBuildSettings.activeBuildTarget, false);
#endif
base.Export(); //分析依赖关系
var all = AssetBundleUtils.GetAll();
try
{
SetSpriteAtlasInBuild(all, false);
ExportImp();
}
finally
{
SetSpriteAtlasInBuild(all, true);
}
}
private void DrawSettings()
{
EditorGUI.BeginDisabledGroup(isRecording);
EditorGUILayout.BeginVertical("Box");
EditorGUILayout.LabelField("Settings", EditorStyles.toolbarDropDown);
EditorGUILayout.Space();
recordOnPlay = EditorGUILayout.Toggle("Record on play", recordOnPlay);
EditorGUI.BeginChangeCheck();
spriteUsageSizeThreshold =
EditorGUILayout.Slider("Allowed Size Variation", spriteUsageSizeThreshold, 0, 2);
if (EditorGUI.EndChangeCheck())
{
SpriteAuditorUtility.SetSizeCheckThreshold(spriteUsageSizeThreshold);
SpriteDatabase.SizeCheckThresholdChanged();
//TODO
//SpriteDatabase.SetAllowedSizeVariation(spriteUsageSizeThreshold);
}
EditorGUILayout.BeginHorizontal();
EditorGUI.BeginDisabledGroup(!EditorPrefs.HasKey(ATLAS_AUDITOR_STORAGE_KEY));
if (GUILayout.Button("Clear Cache", EditorStyles.toolbarButton))
{
ClearCache();
}
if (GUILayout.Button("Pack Atlases", EditorStyles.toolbarButton))
{
SpriteAtlasUtility.PackAllAtlases(EditorUserBuildSettings.activeBuildTarget);
}
if (GUILayout.Button("Refresh Atlases", EditorStyles.toolbarButton))
{
AtlasCacheUtility.CacheKnowAtlases();
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
EditorGUI.EndDisabledGroup();
}
private static void BeforeBuild()
{
CleanUpDeletedScenes();
KeyStore();
SpriteAtlasUtility.PackAllAtlases(EditorUserBuildSettings.activeBuildTarget, false);
AssetDatabase.SaveAssets();
PrintAllEnviromentVariables();
WriteBuildInfoFile();
SetupBuildVersion();
SetupBuildBundleVersion();
AssetDatabase.SaveAssets();
BuildAddressable();
}
internal static void PackAllSpriteAtlases()
{
SpriteAtlasUtility.PackAllAtlases(EditorUserBuildSettings.activeBuildTarget, canCancel: false);
m_SpriteAtlasTextureCache.Clear();
m_TextureSpriteAtlasCache.Clear();
var atlases = Resources.FindObjectsOfTypeAll <SpriteAtlas>();
foreach (var atlas in atlases)
{
var sprites = GetPackedSprites(atlas);
var texture = sprites.FirstOrDefault()?.GetAtlasTexture() ?? null;
if (texture && texture != null)
{
m_SpriteAtlasTextureCache.Add(atlas, texture);
m_TextureSpriteAtlasCache.Add(texture, atlas);
}
}
}
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);
}
static void CreateSpriteAtlas()
{
Object[] objs = Selection.objects;
string selePath = AssetDatabase.GetAssetPath(objs[0]);
string spriteAtlasName = Directory.GetParent(AssetDatabase.GetAssetPath(objs[0])).Name; //图集名字
if ((AssetDatabase.LoadAssetAtPath(selePath, typeof(Sprite))) == null)
{
Debug.LogError("请选择需要打包的Sprite图片");
return; //返回
}
int index = selePath.LastIndexOf("/");
selePath = selePath.Remove(index, selePath.Length - index);
SpriteAtlas spriteAtlas = new SpriteAtlas();
SpriteAtlasExtensions.Add(spriteAtlas, objs);
AssetDatabase.CreateAsset(spriteAtlas, selePath + "/" + spriteAtlasName + ".spriteatlas");
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget);
Debug.Log(ColorToolRich.ColorYellow("图集打包成功"));
}
public static void CreateAtlases()
{
DeleteAtlases();
Utility.CreateDirectory(Utility.GetPluginPath(), Utility.GetAtlasesFolderName());
Dictionary <string, SpriteAtlas> atlasDictionary = GenerateAtlases();
foreach (KeyValuePair <string, SpriteAtlas> pair in atlasDictionary)
{
string directory = pair.Key;
SpriteAtlas atlas = pair.Value;
string name = directory.Replace('/', '_');
string assetPath = Utility.GetOutputPath() + "/" + name + ".spriteatlas";
AssetDatabase.CreateAsset(atlas, assetPath);
}
SpriteAtlasUtility.PackAllAtlases(EditorUserBuildSettings.activeBuildTarget);
AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
}
public void FindSpriteInAtlas(Action <string, string, float> progressAction)
{
List <string> atlasPaths = (from path in m_BundleAssetPathList
where Path.GetExtension(path).ToLower() == ".spriteatlas"
select path).ToList();
int m_FindIndex = 0;
atlasPaths.ForEach((atlasPath) =>
{
progressAction?.Invoke("Find Sprite In Atlas", atlasPath, m_FindIndex / (float)m_BundleAssetPathList.Count);
m_FindIndex++;
SpriteAtlas atlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(atlasPath);
if (atlas != null)
{
string[] spriteInAtlas = SpriteAtlasUtility.GetDependAssets(atlas);
Array.ForEach(spriteInAtlas, spritePath =>
{
m_SpriteInAtlasDic.Add(spritePath, atlasPath);
});
}
});
}
public static void MakeAtlas(string selectPath)
{
var destAtlasParentDir = "Assets/BundleResources/BuildByDir/UI/spriteatlas";
if (!Directory.Exists(destAtlasParentDir))
{
Directory.CreateDirectory(destAtlasParentDir);
}
var dirInfo = new DirectoryInfo(selectPath);
var atlasName = dirInfo.Name;
if (atlasName == "english" || atlasName == "chinese")
{
atlasName = dirInfo.Parent.Name + "_" + atlasName;
}
var destAtlasDir = destAtlasParentDir + "/" + atlasName;
if (!Directory.Exists(destAtlasDir))
{
Directory.CreateDirectory(destAtlasDir);
}
var destAtlasFileName = destAtlasDir + "/" + atlasName + ".spriteatlas";
SpriteAtlas tmpAtlas = null;
if (!File.Exists(destAtlasFileName))
{
tmpAtlas = new SpriteAtlas();
AssetDatabase.CreateAsset(tmpAtlas, destAtlasFileName);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
else
{
tmpAtlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(destAtlasFileName);
}
if (tmpAtlas == null)
{
return;
}
tmpAtlas.Remove(tmpAtlas.GetPackables());
var selectDir = AssetDatabase.LoadAssetAtPath <Object>(selectPath);
tmpAtlas.Add(new Object[] { selectDir });
//////////////////////////////////
var packageSetting = tmpAtlas.GetPackingSettings();
packageSetting.enableRotation = false;
packageSetting.enableTightPacking = false;
packageSetting.padding = 2;
tmpAtlas.SetPackingSettings(packageSetting);
//////////////////////////////////
var texSetting = tmpAtlas.GetTextureSettings();
texSetting.readable = false;
texSetting.generateMipMaps = false;
texSetting.sRGB = true;
texSetting.filterMode = FilterMode.Bilinear;
tmpAtlas.SetTextureSettings(texSetting);
//////////////////////////////////
var standaloneSettings = tmpAtlas.GetPlatformSettings("Standalone");
standaloneSettings.maxTextureSize = 2048;
standaloneSettings.format = TextureImporterFormat.DXT5;
standaloneSettings.overridden = true;
tmpAtlas.SetPlatformSettings(standaloneSettings);
var androidSettings = tmpAtlas.GetPlatformSettings("Android");
androidSettings.maxTextureSize = 2048;
androidSettings.format = TextureImporterFormat.ETC2_RGBA8;
androidSettings.overridden = true;
tmpAtlas.SetPlatformSettings(androidSettings);
var iosSettings = tmpAtlas.GetPlatformSettings("iPhone");
iosSettings.maxTextureSize = 2048;
iosSettings.format = TextureImporterFormat.ASTC_RGBA_6x6;
iosSettings.overridden = true;
tmpAtlas.SetPlatformSettings(iosSettings);
/// /////////////////////////////////
SpriteAtlasUtility.PackAllAtlases(BuildTarget.StandaloneWindows64);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
private void DrawSettings()
{
EditorGUI.BeginDisabledGroup(isRecording);
EditorGUILayout.BeginVertical("Box");
EditorGUILayout.LabelField("Settings", EditorStyles.toolbarDropDown);
EditorGUILayout.Space();
EditorGUI.BeginChangeCheck();
recordOnUpdate = EditorGUILayout.Toggle("Record Automatically", recordOnUpdate);
if (EditorGUI.EndChangeCheck())
{
spriteFinder.SetCaptureOnUpdate(recordOnUpdate);
}
if (recordOnUpdate)
{
EditorGUI.BeginChangeCheck();
frameInterval = EditorGUILayout.IntField("Frame Interval", frameInterval);
if (EditorGUI.EndChangeCheck())
{
spriteFinder.SetFrameInterval(frameInterval);
}
}
else
{
bool guiWasEnabled = GUI.enabled;
GUI.enabled = true;
if (GUILayout.Button("Capture Frame"))
{
spriteFinder.CaptureFrame();
}
GUI.enabled = guiWasEnabled;
}
EditorGUI.BeginChangeCheck();
spriteUsageSizeThreshold =
EditorGUILayout.Slider("Allowed Size Variation", spriteUsageSizeThreshold, 0, 2);
if (EditorGUI.EndChangeCheck())
{
SpriteAuditorUtility.SetSizeCheckThreshold(spriteUsageSizeThreshold);
SpriteDatabase.SizeCheckThresholdChanged();
}
EditorGUILayout.BeginHorizontal();
EditorGUI.BeginDisabledGroup(!EditorPrefs.HasKey(ATLAS_AUDITOR_STORAGE_KEY));
if (GUILayout.Button("Clear Cache", EditorStyles.toolbarButton))
{
ClearCache();
}
if (GUILayout.Button("Pack Atlases", EditorStyles.toolbarButton))
{
SpriteAtlasUtility.PackAllAtlases(EditorUserBuildSettings.activeBuildTarget);
}
if (GUILayout.Button("Refresh Atlases", EditorStyles.toolbarButton))
{
AtlasCacheUtility.CacheKnowAtlases();
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
EditorGUI.EndDisabledGroup();
}
public static void CreateSpriteAtlas(string src_path, string dst_path, string atlas_name, bool includeInBuild = true)
{
if (string.IsNullOrEmpty(src_path) || string.IsNullOrEmpty(dst_path) || string.IsNullOrEmpty(atlas_name))
{
Log.LogError($"无法创建图集,路径为空. src_path={src_path} ,dst_path={dst_path} ,atlas_name={atlas_name}");
return;
}
if (!src_path.EndsWith("/"))
{
src_path = src_path + "/";
}
var full_path = Path.GetFullPath(src_path);
if (!Directory.Exists(full_path))
{
Log.Info($"不创建图集,{src_path}下无atlas文件夹");
return;
}
var assets = Directory.GetFiles(full_path, "*.png"); //这里无法过滤两种类型 *.png|*.jpg
if (assets == null || assets.Length == 0)
{
Log.Info($"{src_path}下无图片，不生成图集");
return;
}
SpriteAtlas spriteAtlas = new SpriteAtlas();
if (!dst_path.EndsWith("/"))
{
dst_path = dst_path + "/";
}
if (!Directory.Exists(dst_path))
{
Directory.CreateDirectory(dst_path);
}
AssetDatabase.CreateAsset(spriteAtlas, dst_path + atlas_name + ".spriteatlas");
foreach (var path in assets)
{
var t = src_path + Path.GetFileName(path);
var o = AssetDatabase.LoadAssetAtPath <Sprite>(t);
if (o != null)
{
SpriteAtlasExtensions.Add(spriteAtlas, new Object[] { o });
}
}
//TODO 根据平台设置图集格式 //EditorUserBuildSettings.activeBuildTarget
var atlasSetting = spriteAtlas.GetPlatformSettings(KResourceModule.GetBuildPlatformName());
atlasSetting.maxTextureSize = 2048;
atlasSetting.textureCompression = TextureImporterCompression.Compressed;
atlasSetting.format = TextureImporterFormat.Automatic;
spriteAtlas.SetIncludeInBuild(includeInBuild);
spriteAtlas.SetPlatformSettings(atlasSetting);
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget, false);
AssetDatabase.SaveAssets();
Log.Info($"创建图集{spriteAtlas.name}完成，包含{spriteAtlas.spriteCount}个图片");
}
public static void SetAtlasMaxSize()
{
MethodInfo getPreviewTexturesMI = typeof(SpriteAtlasExtensions).GetMethod("GetPreviewTextures", BindingFlags.Static | BindingFlags.NonPublic);
foreach (string atlasFile in EditorResourcePaths.GetAllAtlasFiles())
{
if (atlasFile.EndsWith(LOW_ATLAS_SUFFIX))
{
continue;
}
SpriteAtlas spriteAtlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(atlasFile);
List <Sprite> sprites = GetSpritesByAtlas(spriteAtlas);
// 统计散图面积之和
int total = 0;
int minSize = 128;
foreach (Sprite sprite in sprites)
{
Rect rect = sprite.textureRect;
int width = Mathf.CeilToInt(rect.width);
int height = Mathf.CeilToInt(rect.height);
minSize = Mathf.Max(minSize, width, height);
total += width * height;
}
// 估算maxTextureSize值
float guessArea = EditorCommonUtils.ToLargerPOT(total, 4);
int guessSize = Mathf.RoundToInt(Mathf.Sqrt(guessArea));
// 如果填充率太低，将估值尺寸减半
if (total <= guessArea * 0.625f)
{
guessSize /= 2;
}
// 用估值尺寸尝试打图集
guessSize = Mathf.Max(guessSize, Mathf.RoundToInt(EditorCommonUtils.ToLargerPOT(minSize, 2)));
foreach (string platform in PLATFORMS)
{
TextureImporterPlatformSettings patformSettings = SpriteAtlasExtensions.GetPlatformSettings(spriteAtlas, platform);
if (patformSettings.maxTextureSize != guessSize)
{
patformSettings.maxTextureSize = guessSize;
SpriteAtlasExtensions.SetPlatformSettings(spriteAtlas, patformSettings);
}
}
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget);
// 计算图集的实际面积
Texture2D[] atlasTextures = (Texture2D[])getPreviewTexturesMI.Invoke(null, new object[] { spriteAtlas });
int area = 0;
for (int i = 0; i < atlasTextures.Length; i++)
{
area += atlasTextures[i].width * atlasTextures[i].height;
}
// 如果估值尺寸效果一般，将其翻倍
if (area > guessSize * guessSize * 2.5f)
{
foreach (string platform in PLATFORMS)
{
TextureImporterPlatformSettings patformSettings = SpriteAtlasExtensions.GetPlatformSettings(spriteAtlas, platform);
patformSettings.maxTextureSize = Mathf.Min(guessSize * 2, MAX_TEXTURE_SIZE);
SpriteAtlasExtensions.SetPlatformSettings(spriteAtlas, patformSettings);
}
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget);
}
else if (area > guessSize * guessSize * 1.5f && area <= guessSize * guessSize * 2)
{
TextureImporterPlatformSettings patformSettings = SpriteAtlasExtensions.GetPlatformSettings(spriteAtlas, "Android");
patformSettings.maxTextureSize = Mathf.Min(guessSize * 2, MAX_TEXTURE_SIZE);
SpriteAtlasExtensions.SetPlatformSettings(spriteAtlas, patformSettings);
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget);
}
SpriteAtlas lowSpriteAtlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(atlasFile.Replace(EditorResourcePaths.ATLAS_SUFFIX, LOW_ATLAS_SUFFIX));
foreach (string platform in PLATFORMS)
{
TextureImporterPlatformSettings patformSettings = SpriteAtlasExtensions.GetPlatformSettings(spriteAtlas, platform);
TextureImporterPlatformSettings lowPatformSettings = SpriteAtlasExtensions.GetPlatformSettings(lowSpriteAtlas, platform);
lowPatformSettings.maxTextureSize = patformSettings.maxTextureSize;
SpriteAtlasExtensions.SetPlatformSettings(lowSpriteAtlas, lowPatformSettings);
}
}
DebugUtil.Log("SetAtlasMaxSize Done!");
}
/// <summary>
/// 资源打包
/// </summary>
public static void BuildAssetBundles(string output, bool rebuild)
{
// 移除所有assetBundleName
string[] assetBundleNames = AssetDatabase.GetAllAssetBundleNames();
foreach (var assetBundleName in assetBundleNames)
{
AssetDatabase.RemoveAssetBundleName(assetBundleName, true);
}
// 设置图集
string dataPath = assetPath + "/data/texture";
string[] directoryPaths = Directory.GetDirectories(dataPath, "*.atlas", SearchOption.AllDirectories);
foreach (var directoryPath in directoryPaths)
{
string relativePath = directoryPath.Replace(assetPath, "Assets");
SetSpriteAtlas(relativePath);
}
// 设置assetBundleName
dataPath = assetPath + "/data";
string[] filePaths = Directory.GetFiles(dataPath, "*.*", SearchOption.AllDirectories);
foreach (var filePath in filePaths)
{
string path = filePath;
if (path.Contains("/Resources/") || path.Contains(@"\Resources\") || path.Contains("/resources/") || path.Contains(@"\resources\"))
{
continue;
}
string extension = Path.GetExtension(path);
switch (extension)
{
case ".meta":
case ".cs":
{ }
continue;
}
if (Path.GetDirectoryName(path).EndsWith(".atlas"))
{
continue;
}
string relativePath = path.Replace(assetPath, "Assets");
var asset = AssetImporter.GetAtPath(relativePath);
switch (extension)
{
case ".lua":
{
path = path.Substring(0, path.Length - ".lua".Length) + ".txt";
}
break;
case ".unity":
{
path = path.Substring(0, path.Length - ".unity".Length) + ".scene";
}
break;
}
asset.assetBundleName = GetAssetBundleName(path);
}
// 打包
if (rebuild && Directory.Exists(output))
{
FileUtil.DeleteFileOrDirectory(output);
AssetDatabase.Refresh();
}
Directory.CreateDirectory(output);
AssetDatabase.Refresh();
SpriteAtlasUtility.PackAllAtlases(buildTarget);
BuildPipeline.BuildAssetBundles(output, BuildAssetBundleOptions.ChunkBasedCompression, buildTarget);
// 移除所有assetBundleName
assetBundleNames = AssetDatabase.GetAllAssetBundleNames();
foreach (var assetBundleName in assetBundleNames)
{
AssetDatabase.RemoveAssetBundleName(assetBundleName, true);
}
// 刷新
AssetDatabase.Refresh();
}
public static void PackingAtlas()
{
SetAssetConfig(true);
SpriteAtlasUtility.PackAllAtlases(EditorUserBuildSettings.activeBuildTarget);
AssetDatabase.Refresh();
}
