public static TextureImporterPlatformSettings getPlatformSettings(
this TextureImporter ti, Platform platform
) => ti.GetPlatformTextureSettings(platform.name);
static public void PackAndOutputSprites(Texture2D[] texs, string atlasAssetPath, string outputPath)
{
Texture2D atlas = new Texture2D(1, 1);
Rect[] rs = atlas.PackTextures(texs, (int)padding, (int)matAtlasSize);//添加多个图片到一个图集中,返回值是每个图片在图集(大图片)中的U坐标等信息
// 把图集写入到磁盘文件，最终在磁盘上会有一个图片生成，这个图片包含了很多小图片
File.WriteAllBytes(outputPath, atlas.EncodeToPNG());
RefreshAsset(atlasAssetPath);//刷新图片
//记录图片的名字，只是用于输出日志用;
StringBuilder names = new StringBuilder();
//SpriteMetaData结构可以让我们编辑图片的一些信息,像图片的name,包围盒border,在图集中的区域rect等
SpriteMetaData[] sheet = new SpriteMetaData[rs.Length];
for (var i = 0; i < sheet.Length; i++)
{
SpriteMetaData meta = new SpriteMetaData();
meta.name = texs[i].name;
meta.rect = rs[i];//这里的rect记录的是单个图片在图集中的uv坐标值
//因为rect最终需要记录单个图片在大图片图集中所在的区域rect，所以我们做如下的处理
meta.rect.Set(
meta.rect.x * atlas.width,
meta.rect.y * atlas.height,
meta.rect.width * atlas.width,
meta.rect.height * atlas.height
);
//如果图片有包围盒信息的话
var spriteInfo = GetSpriteMetaData(meta.name);
if (spriteInfo != null)
{
meta.border = spriteInfo.spriteBorder;
meta.pivot = spriteInfo.spritePivot;
}
sheet[i] = meta;
//打印日志用
names.Append(meta.name);
if (i < sheet.Length - 1)
{
names.Append(",");
}
}
//设置图集的信息
TextureImporter imp = TextureImporter.GetAtPath(atlasAssetPath) as TextureImporter;
imp.textureType = TextureImporterType.Sprite; //图集的类型
imp.textureShape = TextureImporterShape.Texture2D;
imp.spriteImportMode = SpriteImportMode.Multiple; //Multiple表示我们这个大图片(图集)中包含很多小图片
imp.ignorePngGamma = false;
imp.alphaIsTransparency = true;
imp.mipmapEnabled = false;//是否开启mipmap
imp.isReadable = false;
imp.sRGBTexture = true;
imp.compressionQuality = (int)TextureCompressionQuality.Normal;
imp.spritesheet = sheet;//设置图集中小图片的信息(每个图片所在的区域rect等)
TextureImporterPlatformSettings setParam = new TextureImporterPlatformSettings();
#if UNITY_IOS
//ios版本
setParam = importer.GetPlatformTextureSettings("iOS");
setParam.maxTextureSize = 2048;
setParam.overridden = true;
setParam.allowsAlphaSplitting = true;
setParam.format = TextureImporterFormat.ASTC_4x4;
imp.SetPlatformTextureSettings(setParam);
#else
//安卓版本
setParam = imp.GetPlatformTextureSettings("Android"); //必须用Get方法得到，否则Override for Android不会被设为true
setParam.maxTextureSize = 2048;
setParam.overridden = true;
setParam.allowsAlphaSplitting = true;
setParam.format = TextureImporterFormat.ASTC_4x4;
imp.SetPlatformTextureSettings(setParam);
#endif
// 保存并刷新
imp.SaveAndReimport();
spriteList.Clear();
//输出日志
Debug.Log("Atlas create ok. " + names.ToString());
//打出图集后在Unity选中它
EditorGUIUtility.PingObject(AssetDatabase.LoadAssetAtPath(atlasAssetPath, typeof(Texture)));
}
/// <summary>
/// 设置贴图
/// </summary>
/// <param name="assetPath"></param>
public static void SetTextureByTextureType(string assetPath)
{
//初始化忽略列表
InitIgnoreList();
//UI贴图判断
if (!assetPath.Contains(TEXTURE_ASSET_PATH))
{
return;
}
//忽略列表判断
if (IgnoreFormatList.Contains(assetPath))
{
return;
}
Texture2D cTexture2D = AssetDatabase.LoadAssetAtPath <Texture2D>(assetPath);
if (cTexture2D == null)
{
Debug.LogError("Texture Is Nil Path : " + assetPath);
return;
}
TextureImporter ti = AssetImporter.GetAtPath(assetPath) as TextureImporter;
bool is2NSize = Is2NSizeTexture(cTexture2D);
bool isTransparent = ti.DoesSourceTextureHaveAlpha();
//------------------Pc设置
var pfStandalone = ti.GetPlatformTextureSettings("Standalone");
pfStandalone.overridden = true;
pfStandalone.resizeAlgorithm = TextureResizeAlgorithm.Mitchell;
if (is2NSize)
{
pfStandalone.format = isTransparent ? TextureImporterFormat.DXT5 :TextureImporterFormat.DXT1;
}
else
{
pfStandalone.format = isTransparent ? TextureImporterFormat.RGBA32 : TextureImporterFormat.RGB16;
}
ti.SetPlatformTextureSettings(pfStandalone);
pfStandalone.overridden = false;
//-----------------Ios设置
var pfIPhone = ti.GetPlatformTextureSettings("iPhone");
pfIPhone.overridden = true;
pfIPhone.resizeAlgorithm = TextureResizeAlgorithm.Mitchell;
if (is2NSize)
{
pfIPhone.format = isTransparent ? TextureImporterFormat.ASTC_RGBA_4x4 : TextureImporterFormat.ASTC_RGB_4x4;
}
else
{
pfIPhone.format = isTransparent ? TextureImporterFormat.ASTC_RGBA_4x4 : TextureImporterFormat.RGB16;
}
ti.SetPlatformTextureSettings(pfIPhone);
pfIPhone.overridden = false;
//-----------------Android设置
var pfAndroid = ti.GetPlatformTextureSettings("Android");
pfAndroid.overridden = true;
pfAndroid.resizeAlgorithm = TextureResizeAlgorithm.Mitchell;
if (is2NSize)
{
pfAndroid.format = isTransparent ? TextureImporterFormat.ETC2_RGBA8 : TextureImporterFormat.ETC_RGB4;
}
else
{
pfAndroid.format = isTransparent ? TextureImporterFormat.RGBA16 : TextureImporterFormat.RGB16;
}
pfAndroid.androidETC2FallbackOverride = AndroidETC2FallbackOverride.UseBuildSettings;
ti.SetPlatformTextureSettings(pfAndroid);
pfAndroid.overridden = false;
}
/// <summary>
/// Change the import settings of the specified texture asset, making it suitable to be used as a texture atlas.
/// </summary>
public static bool MakeTextureAnAtlas(string path, bool force, bool alphaTransparency)
{
if (string.IsNullOrEmpty(path))
{
return(false);
}
TextureImporter ti = AssetImporter.GetAtPath(path) as TextureImporter;
if (ti == null)
{
return(false);
}
TextureImporterSettings settings = new TextureImporterSettings();
ti.ReadTextureSettings(settings);
bool compressed = true;
if (force ||
settings.readable ||
settings.maxTextureSize > 2048 ||
settings.wrapMode != TextureWrapMode.Clamp ||
settings.npotScale != TextureImporterNPOTScale.ToNearest ||
settings.aniso != 1)
{
compressed = false;
}
int maxTextureSize;
TextureImporterFormat textureFormat;
int compressionQuality;
if (compressed)
{
if (ti.GetPlatformTextureSettings("iPhone", out maxTextureSize, out textureFormat, out compressionQuality))
{
compressed = maxTextureSize <= 2048 && textureFormat == TextureImporterFormat.PVRTC_RGB4 && compressionQuality == 100;
}
else
{
compressed = false;
}
}
if (compressed)
{
if (ti.GetPlatformTextureSettings("Android", out maxTextureSize, out textureFormat, out compressionQuality))
{
compressed = maxTextureSize <= 2048 && textureFormat == TextureImporterFormat.ETC_RGB4 && compressionQuality == 100;
}
else
{
compressed = false;
}
}
if (compressed)
{
if (ti.GetPlatformTextureSettings("WP8", out maxTextureSize, out textureFormat))
{
compressed = maxTextureSize <= 2048 && textureFormat == TextureImporterFormat.DXT1;
}
else
{
compressed = false;
}
}
if (compressed)
{
compressed = (settings.textureFormat == TextureImporterFormat.ARGB32 || settings.textureFormat == TextureImporterFormat.RGBA32) && settings.textureFormat == TextureImporterFormat.AutomaticTruecolor;
}
if (!compressed)
{
settings.ApplyTextureType(TextureImporterType.Default, true);
settings.readable = false;
settings.maxTextureSize = 2048;
settings.wrapMode = TextureWrapMode.Clamp;
settings.npotScale = TextureImporterNPOTScale.ToNearest;
if (settings.mipmapEnabled)
{
settings.filterMode = FilterMode.Trilinear;
}
else
{
settings.filterMode = FilterMode.Bilinear;
}
settings.aniso = 1;
settings.alphaIsTransparency = alphaTransparency;
settings.textureFormat = TextureImporterFormat.AutomaticTruecolor;
ti.SetTextureSettings(settings);
ti.SetPlatformTextureSettings("iPhone", 2048, TextureImporterFormat.PVRTC_RGB4, 100, false);
ti.SetPlatformTextureSettings("Android", 2048, TextureImporterFormat.ETC_RGB4, 100, false);
ti.SetPlatformTextureSettings("WP8", 2048, TextureImporterFormat.DXT1, false);
AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
}
return(true);
}
static public bool MakeTextureReadable(string path, bool force)
{
if (string.IsNullOrEmpty(path))
{
return(false);
}
TextureImporter ti = AssetImporter.GetAtPath(path) as TextureImporter;
if (ti == null)
{
return(false);
}
TextureImporterSettings settings = new TextureImporterSettings();
ti.ReadTextureSettings(settings);
bool readable = true;
if (force || !settings.readable || settings.npotScale != TextureImporterNPOTScale.None || settings.alphaIsTransparency)
{
readable = false;
}
if (readable)
{
int maxTextureSize;
TextureImporterFormat textureFormat;
#if UNITY_IPHONE
if (ti.GetPlatformTextureSettings("iPhone", out maxTextureSize, out textureFormat))
{
readable = (textureFormat == TextureImporterFormat.ARGB32 || textureFormat == TextureImporterFormat.RGBA32);
}
else
{
readable = false;
}
#elif UNITY_ANDROID
if (ti.GetPlatformTextureSettings("Android", out maxTextureSize, out textureFormat))
{
readable = (textureFormat == TextureImporterFormat.ARGB32 || textureFormat == TextureImporterFormat.RGBA32);
}
else
{
readable = false;
}
#elif UNITY_WP8
if (ti.GetPlatformTextureSettings("WP8", out maxTextureSize, out textureFormat))
{
readable = (textureFormat == TextureImporterFormat.ARGB32 || textureFormat == TextureImporterFormat.RGBA32);
}
else
{
readable = false;
}
#else
readable = (settings.textureFormat == TextureImporterFormat.ARGB32 || settings.textureFormat == TextureImporterFormat.RGBA32 || settings.textureFormat == TextureImporterFormat.AutomaticTruecolor);
#endif
}
if (!readable)
{
settings.readable = true;
if (NGUISettings.trueColorAtlas)
{
settings.textureFormat = TextureImporterFormat.AutomaticTruecolor;
}
settings.npotScale = TextureImporterNPOTScale.None;
settings.alphaIsTransparency = false;
#if UNITY_IPHONE
ti.SetPlatformTextureSettings("iPhone", 4096, TextureImporterFormat.ARGB32);
#elif UNITY_ANDROID
ti.SetPlatformTextureSettings("Android", 4096, TextureImporterFormat.ARGB32);
#elif UNITY_WP8
ti.SetPlatformTextureSettings("WP8", 4096, TextureImporterFormat.ARGB32);
#else
settings.textureFormat = TextureImporterFormat.AutomaticTruecolor;
#endif
ti.SetTextureSettings(settings);
AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
}
return(true);
}
public static bool ProcessIosAssetSpriteImport(TextureImporter textureImporter)
{
string name = textureImporter.name;
int maxTextureSize;
TextureImporterFormat textureFormat;
int compressionQuality;
bool needSaveAndReimport = false;
bool needOverride = false;
bool isAlpha = true;
TextureImporterFormat targetTextureImporterFormat = TextureImporterFormat.ETC2_RGBA8;
if (textureImporter.alphaSource != TextureImporterAlphaSource.FromInput)
{
textureImporter.alphaSource = TextureImporterAlphaSource.FromInput;
needOverride = true;
}
if (!textureImporter.DoesSourceTextureHaveAlpha())
{
isAlpha = false;
}
if (textureImporter.GetPlatformTextureSettings("iPhone", out maxTextureSize, out textureFormat, out compressionQuality))
{
if (isAlpha)
{
string[] labs = AssetDatabase.GetLabels(textureImporter);
if (labs.Length >= 1)
{
AssetDatabase.GetLabels(textureImporter).ForEach((x) =>
{
if (x == "TextureImporterFormat_PVRTC_RGBA4")
{
targetTextureImporterFormat = TextureImporterFormat.PVRTC_RGBA4;
}
});
}
}
else
{
targetTextureImporterFormat = TextureImporterFormat.ETC2_RGBA8;
AssetDatabase.GetLabels(textureImporter).ForEach((x) =>
{
if (x == "TextureImporterFormat_PVRTC_RGBA4")
{
targetTextureImporterFormat = TextureImporterFormat.PVRTC_RGB4;
}
});
}
if (textureFormat != targetTextureImporterFormat)
{
needOverride = true;
}
}
else
{
//这个代表是新图需要设置ios的图片格式
needOverride = true;
targetTextureImporterFormat = TextureImporterFormat.ETC2_RGBA8;
if (isAlpha)
{
AssetDatabase.GetLabels(textureImporter).ForEach((x) =>
{
if (x == "TextureImporterFormat_PVRTC_RGBA4")
{
targetTextureImporterFormat = TextureImporterFormat.PVRTC_RGBA4;
}
});
}
else
{
targetTextureImporterFormat = TextureImporterFormat.ETC2_RGB4;
AssetDatabase.GetLabels(textureImporter).ForEach((x) =>
{
if (x == "TextureImporterFormat_PVRTC_RGBA4")
{
targetTextureImporterFormat = TextureImporterFormat.PVRTC_RGB4;
}
});
}
}
if (needOverride)
{
TextureImporterPlatformSettings setting = new TextureImporterPlatformSettings();
setting.overridden = true;
setting.name = "iPhone";
// setting.textureCompression = TextureImporterCompression.CompressedHQ;
setting.crunchedCompression = false;
setting.maxTextureSize = 2048;
setting.compressionQuality = 50;
setting.format = targetTextureImporterFormat;
textureImporter.SetPlatformTextureSettings(setting);
}
return(needOverride);
}
public List <OverSizeInfo> CheckTextureOverMemoSize(float megaBytes)
{
List <OverSizeInfo> overSizeList = new List <OverSizeInfo>();
System.IO.DirectoryInfo directoryInfo = new System.IO.DirectoryInfo(data.path.TextureDirectoryPath);
System.IO.FileInfo[] allFiles = directoryInfo.GetFiles("*.*", System.IO.SearchOption.AllDirectories);
for (int i = 0; i < allFiles.Length; i++)
{
if ((allFiles[i].Name.Contains(".png") || allFiles[i].Name.Contains(".jpg")) && !allFiles[i].Name.Contains(".meta"))
{
if (allFiles[i].Length > megaBytes * 1024 * 1024)
{
string prefabPath = "Assets" + allFiles[i].FullName.Split(new string[] { "\\Assets" }, 0)[1];
Texture Texture = AssetDatabase.LoadAssetAtPath <Texture>(prefabPath);
TextureImporter m = AssetImporter.GetAtPath(prefabPath) as TextureImporter;
int size = Texture.height * Texture.width * 4;
if (size > 1 * 1024 * 1024)
{
float compressSize = ((float)size) / 1024f / 1024f;
switch (m.textureFormat)
{
case TextureImporterFormat.ETC2_RGB4:
compressSize *= 0.125f;
break;
default:
break;
}
int maxSize = 1024;
TextureImporterFormat format = new TextureImporterFormat();
m.GetPlatformTextureSettings("Android", out maxSize, out format);
switch (format)
{
#region Formasts
case TextureImporterFormat.AutomaticCompressed:
break;
case TextureImporterFormat.Automatic16bit:
break;
case TextureImporterFormat.AutomaticTruecolor:
break;
case TextureImporterFormat.AutomaticCrunched:
break;
case TextureImporterFormat.DXT1:
break;
case TextureImporterFormat.DXT5:
break;
case TextureImporterFormat.RGB16:
break;
case TextureImporterFormat.RGB24:
break;
case TextureImporterFormat.Alpha8:
break;
case TextureImporterFormat.ARGB16:
break;
case TextureImporterFormat.RGBA32:
break;
case TextureImporterFormat.ARGB32:
break;
case TextureImporterFormat.RGBA16:
break;
case TextureImporterFormat.DXT1Crunched:
break;
case TextureImporterFormat.DXT5Crunched:
break;
case TextureImporterFormat.PVRTC_RGB2:
break;
case TextureImporterFormat.PVRTC_RGBA2:
break;
case TextureImporterFormat.PVRTC_RGB4:
break;
case TextureImporterFormat.PVRTC_RGBA4:
break;
case TextureImporterFormat.ETC_RGB4:
break;
case TextureImporterFormat.ATC_RGB4:
break;
case TextureImporterFormat.ATC_RGBA8:
break;
case TextureImporterFormat.EAC_R:
break;
case TextureImporterFormat.EAC_R_SIGNED:
break;
case TextureImporterFormat.EAC_RG:
break;
case TextureImporterFormat.EAC_RG_SIGNED:
break;
case TextureImporterFormat.ETC2_RGB4:
compressSize *= 0.125f;
break;
case TextureImporterFormat.ETC2_RGB4_PUNCHTHROUGH_ALPHA:
break;
case TextureImporterFormat.ETC2_RGBA8:
break;
case TextureImporterFormat.ASTC_RGB_4x4:
break;
case TextureImporterFormat.ASTC_RGB_5x5:
break;
case TextureImporterFormat.ASTC_RGB_6x6:
break;
case TextureImporterFormat.ASTC_RGB_8x8:
break;
case TextureImporterFormat.ASTC_RGB_10x10:
break;
case TextureImporterFormat.ASTC_RGB_12x12:
break;
case TextureImporterFormat.ASTC_RGBA_4x4:
break;
case TextureImporterFormat.ASTC_RGBA_5x5:
break;
case TextureImporterFormat.ASTC_RGBA_6x6:
break;
case TextureImporterFormat.ASTC_RGBA_8x8:
break;
case TextureImporterFormat.ASTC_RGBA_10x10:
break;
case TextureImporterFormat.ASTC_RGBA_12x12:
break;
default:
break;
#endregion
}
//Debug.LogError(prefabPath +" 文件大小："+(((float)allFiles[i].Length)/1024f/1024f).ToString("0.00")+" MB, 压缩大小:"+compressSize.ToString("0.00")+"MB");
OverSizeInfo info = new OverSizeInfo();
info.texture = Texture;
info.fileMegaBytes = ((float)allFiles[i].Length) / 1024f / 1024f;
info.compressed4AndoridMegaBytes = compressSize;
overSizeList.Add(info);
}
}
}
}
return(overSizeList);
}
private void OverwriteImportSettings(TextureImporter target, TextureImporter reference, string tagName)
{
target.textureType = reference.textureType;
TextureImporterSettings dstSettings = new TextureImporterSettings();
TextureImporterSettings srcSettings = new TextureImporterSettings();
target.ReadTextureSettings(srcSettings);
reference.ReadTextureSettings(dstSettings);
if (!m_overwriteSpriteSheet)
{
dstSettings.spriteAlignment = srcSettings.spriteAlignment;
dstSettings.spriteBorder = srcSettings.spriteBorder;
dstSettings.spriteExtrude = srcSettings.spriteExtrude;
dstSettings.spriteMode = srcSettings.spriteMode;
dstSettings.spriteMeshType = srcSettings.spriteMeshType;
dstSettings.spritePivot = srcSettings.spritePivot;
dstSettings.spritePixelsPerUnit = srcSettings.spritePixelsPerUnit;
dstSettings.spriteTessellationDetail = srcSettings.spriteTessellationDetail;
}
target.SetTextureSettings(dstSettings);
if (m_overwriteSpriteSheet)
{
target.spritesheet = reference.spritesheet;
}
// some unity version do not properly copy properties via TextureSettings,
// so also perform manual copy
target.anisoLevel = reference.anisoLevel;
target.borderMipmap = reference.borderMipmap;
target.compressionQuality = reference.compressionQuality;
target.convertToNormalmap = reference.convertToNormalmap;
target.fadeout = reference.fadeout;
target.filterMode = reference.filterMode;
target.generateCubemap = reference.generateCubemap;
target.heightmapScale = reference.heightmapScale;
target.isReadable = reference.isReadable;
target.maxTextureSize = reference.maxTextureSize;
target.mipMapBias = reference.mipMapBias;
target.mipmapEnabled = reference.mipmapEnabled;
target.mipmapFadeDistanceEnd = reference.mipmapFadeDistanceEnd;
target.mipmapFadeDistanceStart = reference.mipmapFadeDistanceStart;
target.mipmapFilter = reference.mipmapFilter;
target.normalmapFilter = reference.normalmapFilter;
target.npotScale = reference.npotScale;
if (m_overwritePackingTag)
{
if (!string.IsNullOrEmpty(tagName))
{
target.spritePackingTag = tagName;
}
else
{
target.spritePackingTag = reference.spritePackingTag;
}
}
target.wrapMode = reference.wrapMode;
/* read only */
// importer.qualifiesForSpritePacking
#if !UNITY_5_5_OR_NEWER
// obsolete features
importer.generateMipsInLinearSpace = reference.generateMipsInLinearSpace;
importer.grayscaleToAlpha = reference.grayscaleToAlpha;
importer.lightmap = reference.lightmap;
importer.linearTexture = reference.linearTexture;
importer.normalmap = reference.normalmap;
importer.textureFormat = reference.textureFormat;
foreach (var g in NodeGUIUtility.SupportedBuildTargetGroups)
{
var platformName = BuildTargetUtility.TargetToAssetBundlePlatformName(g, BuildTargetUtility.PlatformNameType.TextureImporter);
int maxTextureSize;
TextureImporterFormat format;
int compressionQuality;
if (reference.GetPlatformTextureSettings(platformName, out maxTextureSize, out format, out compressionQuality))
{
importer.SetPlatformTextureSettings(platformName, maxTextureSize, format, compressionQuality, false);
}
else
{
importer.ClearPlatformTextureSettings(platformName);
}
}
#else
target.allowAlphaSplitting = reference.allowAlphaSplitting;
target.alphaIsTransparency = reference.alphaIsTransparency;
target.textureShape = reference.textureShape;
target.alphaSource = reference.alphaSource;
target.sRGBTexture = reference.sRGBTexture;
target.textureCompression = reference.textureCompression;
target.crunchedCompression = reference.crunchedCompression;
var defaultPlatformSetting = reference.GetDefaultPlatformTextureSettings();
target.SetPlatformTextureSettings(defaultPlatformSetting);
foreach (var g in NodeGUIUtility.SupportedBuildTargetGroups)
{
var platformName = BuildTargetUtility.TargetToAssetBundlePlatformName(g, BuildTargetUtility.PlatformNameType.TextureImporter);
var impSet = reference.GetPlatformTextureSettings(platformName);
target.SetPlatformTextureSettings(impSet);
}
#endif
#if UNITY_2017_1_OR_NEWER
target.alphaTestReferenceValue = reference.alphaTestReferenceValue;
target.mipMapsPreserveCoverage = reference.mipMapsPreserveCoverage;
target.wrapModeU = reference.wrapModeU;
target.wrapModeV = reference.wrapModeV;
target.wrapModeW = reference.wrapModeW;
#endif
}
private bool IsEqual(TextureImporter target, TextureImporter reference, string tagName)
{
// UnityEditor.TextureImporter.textureFormat' is obsolete:
// `textureFormat is not longer accessible at the TextureImporter level
if (target.textureType != reference.textureType)
{
return(false);
}
TextureImporterSettings targetSetting = new TextureImporterSettings();
TextureImporterSettings referenceSetting = new TextureImporterSettings();
target.ReadTextureSettings(targetSetting);
reference.ReadTextureSettings(referenceSetting);
// if m_overwriteSpriteSheet is false, following properties
// should be ignored
if (!m_overwriteSpriteSheet)
{
referenceSetting.spriteAlignment = targetSetting.spriteAlignment;
referenceSetting.spriteBorder = targetSetting.spriteBorder;
referenceSetting.spriteExtrude = targetSetting.spriteExtrude;
referenceSetting.spriteMode = targetSetting.spriteMode;
referenceSetting.spriteMeshType = targetSetting.spriteMeshType;
referenceSetting.spritePivot = targetSetting.spritePivot;
referenceSetting.spritePixelsPerUnit = targetSetting.spritePixelsPerUnit;
referenceSetting.spriteTessellationDetail = targetSetting.spriteTessellationDetail;
}
if (!TextureImporterSettings.Equal(targetSetting, referenceSetting))
{
return(false);
}
if (target.textureType == TextureImporterType.Sprite)
{
if (m_overwritePackingTag)
{
if (!string.IsNullOrEmpty(tagName))
{
if (target.spritePackingTag != tagName)
{
return(false);
}
}
else
{
if (target.spritePackingTag != reference.spritePackingTag)
{
return(false);
}
}
}
if (m_overwriteSpriteSheet)
{
if (target.spriteBorder != reference.spriteBorder)
{
return(false);
}
if (target.spriteImportMode != reference.spriteImportMode)
{
return(false);
}
if (target.spritePivot != reference.spritePivot)
{
return(false);
}
if (target.spritePixelsPerUnit != reference.spritePixelsPerUnit)
{
return(false);
}
var s1 = target.spritesheet;
var s2 = reference.spritesheet;
if (s1.Length != s2.Length)
{
return(false);
}
for (int i = 0; i < s1.Length; ++i)
{
if (s1 [i].alignment != s2 [i].alignment)
{
return(false);
}
if (s1 [i].border != s2 [i].border)
{
return(false);
}
if (s1 [i].name != s2 [i].name)
{
return(false);
}
if (s1 [i].pivot != s2 [i].pivot)
{
return(false);
}
if (s1 [i].rect != s2 [i].rect)
{
return(false);
}
}
}
}
if (target.wrapMode != reference.wrapMode)
{
return(false);
}
if (target.anisoLevel != reference.anisoLevel)
{
return(false);
}
if (target.borderMipmap != reference.borderMipmap)
{
return(false);
}
if (target.compressionQuality != reference.compressionQuality)
{
return(false);
}
if (target.convertToNormalmap != reference.convertToNormalmap)
{
return(false);
}
if (target.fadeout != reference.fadeout)
{
return(false);
}
if (target.filterMode != reference.filterMode)
{
return(false);
}
if (target.generateCubemap != reference.generateCubemap)
{
return(false);
}
if (target.heightmapScale != reference.heightmapScale)
{
return(false);
}
if (target.isReadable != reference.isReadable)
{
return(false);
}
if (target.maxTextureSize != reference.maxTextureSize)
{
return(false);
}
if (target.mipMapBias != reference.mipMapBias)
{
return(false);
}
if (target.mipmapEnabled != reference.mipmapEnabled)
{
return(false);
}
if (target.mipmapFadeDistanceEnd != reference.mipmapFadeDistanceEnd)
{
return(false);
}
if (target.mipmapFadeDistanceStart != reference.mipmapFadeDistanceStart)
{
return(false);
}
if (target.mipmapFilter != reference.mipmapFilter)
{
return(false);
}
if (target.normalmapFilter != reference.normalmapFilter)
{
return(false);
}
if (target.npotScale != reference.npotScale)
{
return(false);
}
/* read only properties */
// target.qualifiesForSpritePacking
#if !UNITY_5_5_OR_NEWER
// obsolete features
if (target.normalmap != reference.normalmap)
{
return(false);
}
if (target.linearTexture != reference.linearTexture)
{
return(false);
}
if (target.lightmap != reference.lightmap)
{
return(false);
}
if (target.grayscaleToAlpha != reference.grayscaleToAlpha)
{
return(false);
}
if (target.generateMipsInLinearSpace != reference.generateMipsInLinearSpace)
{
return(false);
}
if (target.textureFormat != reference.textureFormat)
{
return(false);
}
foreach (var g in NodeGUIUtility.SupportedBuildTargetGroups)
{
var platformName = BuildTargetUtility.TargetToAssetBundlePlatformName(g, BuildTargetUtility.PlatformNameType.TextureImporter);
int srcMaxTextureSize;
TextureImporterFormat srcFormat;
int srcCompressionQuality;
int dstMaxTextureSize;
TextureImporterFormat dstFormat;
int dstCompressionQuality;
var srcHasSetting = target.GetPlatformTextureSettings(platformName, out srcMaxTextureSize, out srcFormat, out srcCompressionQuality);
var dstHasSetting = reference.GetPlatformTextureSettings(platformName, out dstMaxTextureSize, out dstFormat, out dstCompressionQuality);
if (srcHasSetting != dstHasSetting)
{
return(false);
}
if (srcMaxTextureSize != dstMaxTextureSize)
{
return(false);
}
if (srcFormat != dstFormat)
{
return(false);
}
if (srcCompressionQuality != dstCompressionQuality)
{
return(false);
}
}
#else
if (target.allowAlphaSplitting != reference.allowAlphaSplitting)
{
return(false);
}
if (target.alphaIsTransparency != reference.alphaIsTransparency)
{
return(false);
}
if (target.textureShape != reference.textureShape)
{
return(false);
}
if (target.alphaSource != reference.alphaSource)
{
return(false);
}
if (target.sRGBTexture != reference.sRGBTexture)
{
return(false);
}
if (target.textureCompression != reference.textureCompression)
{
return(false);
}
if (target.crunchedCompression != reference.crunchedCompression)
{
return(false);
}
var refDefault = reference.GetDefaultPlatformTextureSettings();
var impDefault = target.GetDefaultPlatformTextureSettings();
if (!CompareImporterPlatformSettings(refDefault, impDefault))
{
return(false);
}
foreach (var g in NodeGUIUtility.SupportedBuildTargetGroups)
{
var platformName = BuildTargetUtility.TargetToAssetBundlePlatformName(g, BuildTargetUtility.PlatformNameType.TextureImporter);
var impSet = reference.GetPlatformTextureSettings(platformName);
var targetImpSet = target.GetPlatformTextureSettings(platformName);
if (!CompareImporterPlatformSettings(impSet, targetImpSet))
{
return(false);
}
}
#endif
#if UNITY_2017_1_OR_NEWER
if (target.alphaTestReferenceValue != reference.alphaTestReferenceValue)
{
return(false);
}
if (target.mipMapsPreserveCoverage != reference.mipMapsPreserveCoverage)
{
return(false);
}
if (target.wrapModeU != reference.wrapModeU)
{
return(false);
}
if (target.wrapModeV != reference.wrapModeV)
{
return(false);
}
if (target.wrapModeW != reference.wrapModeW)
{
return(false);
}
#endif
return(true);
}
void SetTextureFormat(Texture2D tx, TextureFormatInfo tfi, bool addToList, bool setNormalMap)
{
AssetImporter ai = AssetImporter.GetAtPath(AssetDatabase.GetAssetOrScenePath(tx));
if (ai != null && ai is UnityEditor.TextureImporter)
{
string s;
if (addToList)
{
s = "Setting texture format for ";
}
else
{
s = "Restoring texture format for ";
}
s += tx + " to " + tfi.format;
if (tfi.platform != null)
{
s += " setting platform override format for " + tfi.platform + " to " + tfi.platformOverrideFormat;
}
Debug.Log(s);
TextureImporter textureImporter = (TextureImporter)ai;
TextureFormatInfo restoreTfi = new TextureFormatInfo(textureImporter.textureFormat,
tfi.platform,
TextureImporterFormat.AutomaticTruecolor,
textureImporter.normalmap);
string platform = tfi.platform;
bool doImport = false;
if (platform != null)
{
int maxSize;
TextureImporterFormat f;
textureImporter.GetPlatformTextureSettings(platform, out maxSize, out f);
restoreTfi.platformOverrideFormat = f;
if (f != 0) //f == 0 means no override or platform doesn't exist
{
textureImporter.SetPlatformTextureSettings(platform, maxSize, tfi.platformOverrideFormat);
doImport = true;
}
}
if (textureImporter.textureFormat != tfi.format)
{
textureImporter.textureFormat = tfi.format;
doImport = true;
}
if (textureImporter.normalmap && !setNormalMap)
{
textureImporter.normalmap = false;
doImport = true;
}
if (!textureImporter.normalmap && setNormalMap)
{
textureImporter.normalmap = true;
doImport = true;
}
if (addToList && !_textureFormatMap.ContainsKey(tx))
{
_textureFormatMap.Add(tx, restoreTfi);
}
if (doImport)
{
AssetDatabase.ImportAsset(AssetDatabase.GetAssetOrScenePath(tx), ImportAssetOptions.ForceUpdate);
}
}
}