public static (int Width, int Height, string Extension) Find(TextureSettings settings, string texture)
{
(Stream? stream, string?path) = FindStream(settings, texture);
if (stream is null)
{
return(0, 0, path);
}
try
{
using var image = Image.Load(stream);
return(image.Width, image.Height, path);
}
catch
{
try
{
using var tga = Pfim.Pfim.FromStream(stream);
return(tga.Width, tga.Height, path);
}
catch
{
return(0, 0, path);
}
}
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion));
node.Add(WidthName, Width);
node.Add(HeightName, Height);
node.Add(AntiAliasingName, AntiAliasing);
if (IsReadMipCount(container.ExportVersion))
{
node.Add(MipCountName, MipCount);
}
node.Add(DepthFormatName, DepthFormat);
node.Add(ColorFormatName, (int)ColorFormat);
node.Add(MipMapName, MipMap);
node.Add(GenerateMipsName, GenerateMips);
node.Add(SRGBName, SRGB);
node.Add(UseDynamicScaleName, UseDynamicScale);
node.Add(BindMSName, BindMS);
if (IsReadEnableCompatibleFormat(container.ExportVersion))
{
node.Add(EnableCompatibleFormatName, GetEnableCompatibleFormat(container.Version));
}
node.Add(TextureSettingsName, TextureSettings.ExportYAML(container));
node.Add(DimensionName, Dimension);
node.Add(VolumeDepthName, VolumeDepth);
return(node);
}
protected override void WriteObject(AssetsWriter writer)
{
base.WriteBase(writer);
writer.Write(Name);
writer.Write(ForcedFallbackFormat);
writer.Write(DownscaleFallback);
writer.AlignTo(4);
writer.Write(Width);
writer.Write(Height);
writer.Write(CompleteImageSize);
writer.Write((int)TextureFormat);
writer.Write(MipCount);
writer.Write(IsReadable);
writer.Write(StreamingMipmaps);
writer.AlignTo(4);
writer.Write(StreamingMipmapsPriority);
writer.Write(ImageCount);
writer.Write(TextureDimension);
TextureSettings.Write(writer);
writer.Write(LightmapFormat);
writer.Write(ColorSpace);
writer.Write(ImageData.Length);
writer.Write(ImageData);
writer.AlignTo(4);
StreamData.Write(writer);
}
protected sealed override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
if (HasColorSpace(container.ExportVersion))
{
node.Add(ColorSpaceName, (int)ColorSpace);
}
node.Add(FormatName, (int)Format);
node.Add(WidthName, Width);
node.Add(HeightName, Height);
node.Add(DepthName, Depth);
node.Add(MipCountName, MipCount);
node.Add(DataSizeName, DataSize);
node.Add(TextureSettingsName, TextureSettings.ExportYAML(container));
node.Add(IsReadableName, IsReadable);
IReadOnlyList <byte> imageData = GetImageData(container.Version);
node.Add(ImageDataName, imageData.Count);
node.Add(TypelessdataName, imageData.ExportYAML());
StreamingInfo streamData = new StreamingInfo(true);
node.Add(StreamDataName, streamData.ExportYAML(container));
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion));
node.Add(WidthName, Width);
node.Add(HeightName, Height);
node.Add(CompleteImageSizeName, CompleteImageSize);
node.Add(TextureFormatName, (int)TextureFormat);
node.Add(MipCountName, MipCount);
node.Add(IsReadableName, IsReadable);
if (IsReadStreamingMipmaps(container.ExportVersion))
{
node.Add(StreamingMipmapsName, StreamingMipmaps);
}
if (IsReadStreamingMipmapsPriority(container.ExportVersion))
{
node.Add(StreamingMipmapsPriorityName, StreamingMipmapsPriority);
}
node.Add(AlphaIsTransparencyName, GetAlphaIsTransparency(container.Version, container.Flags));
node.Add(ImageCountName, ImageCount);
node.Add(TextureDimensionName, (int)TextureDimension);
node.Add(TextureSettingsName, TextureSettings.ExportYAML(container));
node.Add(LightmapFormatName, (int)LightmapFormat);
node.Add(ColorSpaceName, (int)ColorSpace);
IReadOnlyList <byte> imageData = GetExportImageData();
node.Add(ImageDataName, imageData.Count);
node.Add(TypelessdataName, imageData.ExportYAML());
StreamingInfo streamData = new StreamingInfo(true);
node.Add(StreamDataName, streamData.ExportYAML(container));
return(node);
}
private LaTeXTextureDownloader(string[, , ] laTeX, TextureSettings?settings)
{
this.laTeXTensor = laTeX;
this.settings = settings ?? new TextureSettings()
{
size = Size.normal
};
}
public Texture2D(AssetInfo assetInfo) :
base(assetInfo)
{
TextureSettings = new TextureSettings(assetInfo.AssetFile);
if (IsReadStreamData)
{
StreamData = new StreamingInfo();
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
Width = stream.ReadInt32();
Height = stream.ReadInt32();
CompleteImageSize = stream.ReadInt32();
TextureFormat = (TextureFormat)stream.ReadInt32();
if (IsBoolMinMap(stream.Version))
{
MipMap = stream.ReadBoolean();
if (MipMap)
{
int maxSide = Math.Max(Width, Height);
MipCount = Convert.ToInt32(Math.Log(maxSide) / Math.Log(2));
}
else
{
MipCount = 1;
}
}
else
{
MipCount = stream.ReadInt32();
}
if (IsReadIsReadable(stream.Version))
{
IsReadable = stream.ReadBoolean();
}
if (IsReadReadAllowed(stream.Version))
{
ReadAllowed = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
ImageCount = stream.ReadInt32();
TextureDimension = stream.ReadInt32();
TextureSettings.Read(stream);
if (IsReadLightmapFormat(stream.Version))
{
LightmapFormat = stream.ReadInt32();
}
if (IsReadColorSpace(stream.Version))
{
ColorSpace = (ColorSpace)stream.ReadInt32();
}
m_imageData = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
if (IsReadStreamData(stream.Version))
{
StreamData.Read(stream);
}
}
private bool IsOptimized()
{
foreach (var oTarget in serializedObject.targetObjects)
{
var myTarget = oTarget as BbSprite;
Debug.Assert(myTarget != null, "myTarget != null");
if (!TextureSettings.IsAtlasOptimalForBbSprite(myTarget.Atlas))
{
return(false);
}
}
return(true);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.Add(TextureSettingsName, TextureSettings.ExportYAML(container));
node.Add(IsReadableName, IsReadable);
if (HasSRGBTexture(container.ExportVersion))
{
node.Add(SRGBTextureName, SRGBTexture);
}
if (HasStreamingMipmaps(container.ExportVersion))
{
node.Add(StreamingMipmapsName, StreamingMipmaps);
node.Add(StreamingMipmapsPriorityName, StreamingMipmapsPriority);
}
PostExportYAML(container, node);
return(node);
}
private void Optimize()
{
if (EditorUtility.DisplayDialog(
"Turn off blurring",
"This will alter the current texture's settings to remove " +
"blur/antialiasing/etc.\nThe texture's pixels will be sharp and " +
"unobscured.\n\nWarning: These changes must be undone manually.\n" +
"They include:\n" + TextureSettings.BbSpriteOptimalSettingsList,
"OK", "Cancel"))
{
foreach (var oTarget in serializedObject.targetObjects)
{
var myTarget = oTarget as BbSprite;
Debug.Assert(myTarget != null, "myTarget != null");
TextureSettings.SetAtlasAsOptimalForBbSprite(myTarget.Atlas);
myTarget.Update();
}
}
}
protected override YAMLMappingNode ExportYAMLRoot(IAssetsExporter exporter)
{
YAMLMappingNode node = base.ExportYAMLRoot(exporter);
node.Add("m_Width", Width);
node.Add("m_Height", Height);
node.Add("m_AntiAliasing", AntiAliasing);
node.Add("m_DepthFormat", DepthFormat);
node.Add("m_ColorFormat", (int)ColorFormat);
node.Add("m_MipMap", MipMap);
node.Add("m_GenerateMips", GenerateMips);
node.Add("m_SRGB", SRGB);
node.Add("m_UseDynamicScale", UseDynamicScale);
node.Add("m_BindMS", BindMS);
node.Add("m_TextureSettings", TextureSettings.ExportYAML(exporter));
node.Add("m_Dimension", Dimension);
node.Add("m_VolumeDepth", VolumeDepth);
return(node);
}
public override void Read(AssetReader reader)
{
base.Read(reader);
TextureSettings.Read(reader);
IsReadable = reader.ReadBoolean();
if (HasSRGBTexture(reader.Version))
{
SRGBTexture = reader.ReadBoolean();
}
if (HasStreamingMipmaps(reader.Version))
{
StreamingMipmaps = reader.ReadBoolean();
reader.AlignStream();
StreamingMipmapsPriority = reader.ReadInt32();
}
reader.AlignStream();
PostRead(reader);
}
public override void Write(AssetWriter writer)
{
base.Write(writer);
TextureSettings.Write(writer);
writer.Write(IsReadable);
if (HasSRGBTexture(writer.Version))
{
writer.Write(SRGBTexture);
}
if (HasStreamingMipmaps(writer.Version))
{
writer.Write(StreamingMipmaps);
writer.AlignStream();
writer.Write(StreamingMipmapsPriority);
}
writer.AlignStream();
PostWrite(writer);
}
public YAMLNode ExportYAML(IExportContainer container)
{
int version = TextureSettings.GetSerializedVersion(container.Version);
YAMLMappingNode node = new YAMLMappingNode();
node.AddSerializedVersion(version);
node.Add("filterMode", (int)m_textureSettings.FilterMode);
node.Add("aniso", m_textureSettings.Aniso);
node.Add("mipBias", m_textureSettings.MipBias);
if (version >= 2)
{
node.Add("wrapU", (int)m_textureSettings.WrapU);
node.Add("wrapV", (int)m_textureSettings.WrapV);
node.Add("wrapW", (int)m_textureSettings.WrapW);
}
else
{
node.Add("wrapMode", (int)m_textureSettings.WrapU);
}
return(node);
}
private void GUI2DArray()
{
oldTexList = TexList;
GUILayout.Label("Texture List");
TexList = EditorGUILayout.ObjectField("", TexList, typeof(TextureList), false) as TextureList;
/* Copy the settings over from the first texture when a new texture list is put in the object field **/
if (oldTexList != TexList && TexList != null && TexList.TexArray.Length > 0 && TexList.TexArray[0] != null)
{
filterMode = TexList.TexArray[0].filterMode;
anisoLevel = TexList.TexArray[0].anisoLevel;
wrapModeU = TexList.TexArray[0].wrapModeU;
wrapModeV = TexList.TexArray[0].wrapModeV;
if (wrapModeU == wrapModeV)
{
wrapMode = (int)wrapModeU;
}
else
{
wrapMode = 4;
}
}
/* Do we want mip maps? if so, copy them from the source textures **/
copyMips = EditorGUILayout.Toggle("Copy Mip Maps", copyMips);
if (copyMips)
{
mipMapBias = EditorGUILayout.FloatField(" Mip Map Bias", mipMapBias);
}
filterMode = (FilterMode)EditorGUILayout.Popup("Filter Mode", (int)filterMode, filters);
/* Set the wrap mode to the same value on both axes unless wrapMode is 4 (Per Axis), then show separate options**/
wrapMode = EditorGUILayout.Popup("Wrap Mode", wrapMode, wraps);
if (wrapMode == 4)
{
wrapModeU = (TextureWrapMode)EditorGUILayout.Popup(" U Axis", (int)wrapModeU, wrapsAxis);
wrapModeV = (TextureWrapMode)EditorGUILayout.Popup(" V Axis", (int)wrapModeV, wrapsAxis);
}
else
{
wrapModeU = (TextureWrapMode)wrapMode;
wrapModeV = (TextureWrapMode)wrapMode;
}
anisoLevel = EditorGUILayout.IntSlider("Aniso Level", anisoLevel, 0, 16);
/* Show the user the settings that are going to be copied over from the source textures directly **/
showProperties = EditorGUILayout.Foldout(showProperties, "Inherited Properties", true);
if (showProperties && TexList != null)
{
printProperties(TexList.TexArray);
}
GUILayout.FlexibleSpace();
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("Create Array", GUILayout.Width(100), GUILayout.Height(30)))
{
TextureSettings settings = new TextureSettings();
settings.filterMode = filterMode;
settings.copyMips = copyMips;
settings.mipMapBias = mipMapBias;
settings.wrapModeU = wrapModeU;
settings.wrapModeV = wrapModeV;
settings.anisoLevel = anisoLevel;
CopyListIntoArray(TexList, settings);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadIsPowerOfTwo(stream.Version))
{
if (IsReadIsPowerOfTwoFirst(stream.Version))
{
IsPowerOfTwo = stream.ReadBoolean();
}
}
Width = stream.ReadInt32();
Height = stream.ReadInt32();
if (IsReadAntiAliasing(stream.Version))
{
AntiAliasing = stream.ReadInt32();
}
DepthFormat = stream.ReadInt32();
if (IsReadColorFormat(stream.Version))
{
ColorFormat = (RenderTextureFormat)stream.ReadInt32();
}
if (IsReadIsPowerOfTwo(stream.Version))
{
if (!IsReadIsPowerOfTwoFirst(stream.Version))
{
IsPowerOfTwo = stream.ReadBoolean();
}
}
if (IsReadIsCubemap(stream.Version))
{
IsCubemap = stream.ReadBoolean();
}
if (IsReadMipMap(stream.Version))
{
MipMap = stream.ReadBoolean();
}
if (IsReadGenerateMips(stream.Version))
{
GenerateMips = stream.ReadBoolean();
}
if (IsReadSRGB(stream.Version))
{
SRGB = stream.ReadBoolean();
}
if (IsReadUseDynamicScale(stream.Version))
{
UseDynamicScale = stream.ReadBoolean();
BindMS = stream.ReadBoolean();
}
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
TextureSettings.Read(stream);
if (IsReadDimension(stream.Version))
{
Dimension = stream.ReadInt32();
VolumeDepth = stream.ReadInt32();
}
}
/// <summary>
/// Finds the specified texture with the given search settings.
/// </summary>
/// <param name="settings">The settings for the texture search.</param>
/// <param name="texture">The texture name.</param>
/// <returns>The data stream of the texture.</returns>
private static (Stream?Stream, string Extension) FindStream(TextureSettings settings, string texture)
=> FindInDirectory(settings, texture.Split('/', '\\'), new List <string>());
public override void Read(AssetReader reader)
{
base.Read(reader);
if (HasColorSpace(reader.Version))
{
if (IsColorSpaceFirst(reader.Version))
{
ColorSpace = (ColorSpace)reader.ReadInt32();
}
}
if (IsFormatFirst(reader.Version))
{
Format = (TextureFormat)reader.ReadInt32();
}
Width = reader.ReadInt32();
Height = reader.ReadInt32();
if (HasDepth(reader.Version))
{
Depth = reader.ReadInt32();
}
if (IsDataSizeFirst(reader.Version))
{
DataSize = reader.ReadInt32();
}
if (!IsFormatFirst(reader.Version))
{
Format = (TextureFormat)reader.ReadInt32();
}
if (IsBoolMinMap(reader.Version))
{
bool mipMap = reader.ReadBoolean();
if (mipMap)
{
int maxSide = Math.Max(Width, Height);
MipCount = System.Convert.ToInt32(Math.Log(maxSide) / Math.Log(2));
}
else
{
MipCount = 1;
}
}
else
{
MipCount = reader.ReadInt32();
}
if (!IsDataSizeFirst(reader.Version))
{
DataSize = reader.ReadInt32();
}
if (IsReadableFirst(reader.Version))
{
IsReadable = reader.ReadBoolean();
}
if (HasReadAllowed(reader.Version))
{
ReadAllowed = reader.ReadBoolean();
}
reader.AlignStream();
if (HasImageCount(reader.Version))
{
ImageCount = reader.ReadInt32();
TextureDimension = (TextureDimension)reader.ReadInt32();
}
TextureSettings.Read(reader);
if (IsReadableSecond(reader.Version))
{
IsReadable = reader.ReadBoolean();
reader.AlignStream();
}
if (HasLightmapFormat(reader.Version))
{
LightmapFormat = (TextureUsageMode)reader.ReadInt32();
}
if (HasColorSpace(reader.Version))
{
if (!IsColorSpaceFirst(reader.Version))
{
ColorSpace = (ColorSpace)reader.ReadInt32();
}
}
m_imageData = reader.ReadByteArray();
reader.AlignStream();
if (HasStreamData(reader.Version))
{
StreamData.Read(reader);
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
#if UNIVERSAL
bool hasAlphaIsTransparency = HasAlphaIsTransparency(reader.Version, reader.Flags);
int alphaIsTransparencyOrder = GetAlphaIsTransparencyOrder(reader.Version);
if (hasAlphaIsTransparency && alphaIsTransparencyOrder == 0)
{
AlphaIsTransparency = reader.ReadBoolean();
reader.AlignStream();
}
#endif
Width = reader.ReadInt32();
Height = reader.ReadInt32();
CompleteImageSize = reader.ReadInt32();
TextureFormat = (TextureFormat)reader.ReadInt32();
if (IsBoolMinMap(reader.Version))
{
bool mipMap = reader.ReadBoolean();
if (mipMap)
{
int maxSide = Math.Max(Width, Height);
MipCount = System.Convert.ToInt32(Math.Log(maxSide) / Math.Log(2));
}
else
{
MipCount = 1;
}
}
else
{
MipCount = reader.ReadInt32();
}
if (HasReadable(reader.Version))
{
IsReadable = reader.ReadBoolean();
}
if (HasIgnoreMasterTextureLimit(reader.Version))
{
IgnoreMasterTextureLimit = reader.ReadBoolean();
}
if (HasIsPreProcessed(reader.Version))
{
IsPreProcessed = reader.ReadBoolean();
}
if (HasReadAllowed(reader.Version))
{
ReadAllowed = reader.ReadBoolean();
}
if (HasStreamingMipmaps(reader.Version))
{
StreamingMipmaps = reader.ReadBoolean();
}
#if UNIVERSAL
if (hasAlphaIsTransparency && alphaIsTransparencyOrder == 1)
{
AlphaIsTransparency = reader.ReadBoolean();
}
#endif
reader.AlignStream();
if (HasStreamingMipmapsPriority(reader.Version))
{
StreamingMipmapsPriority = reader.ReadInt32();
#if UNIVERSAL
if (hasAlphaIsTransparency && alphaIsTransparencyOrder == 2)
{
AlphaIsTransparency = reader.ReadBoolean();
}
#endif
reader.AlignStream();
}
ImageCount = reader.ReadInt32();
TextureDimension = (TextureDimension)reader.ReadInt32();
TextureSettings.Read(reader);
if (HasLightmapFormat(reader.Version))
{
LightmapFormat = (TextureUsageMode)reader.ReadInt32();
}
if (HasColorSpace(reader.Version))
{
ColorSpace = (ColorSpace)reader.ReadInt32();
}
m_imageData = reader.ReadByteArray();
reader.AlignStream();
if (HasStreamData(reader.Version))
{
StreamData.Read(reader);
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadIsPowerOfTwo(reader.Version))
{
if (IsReadIsPowerOfTwoFirst(reader.Version))
{
IsPowerOfTwo = reader.ReadBoolean();
}
}
Width = reader.ReadInt32();
Height = reader.ReadInt32();
if (IsReadAntiAliasing(reader.Version))
{
AntiAliasing = reader.ReadInt32();
}
DepthFormat = reader.ReadInt32();
if (IsReadColorFormat(reader.Version))
{
ColorFormat = (RenderTextureFormat)reader.ReadInt32();
}
if (IsReadIsPowerOfTwo(reader.Version))
{
if (!IsReadIsPowerOfTwoFirst(reader.Version))
{
IsPowerOfTwo = reader.ReadBoolean();
}
}
if (IsReadIsCubemap(reader.Version))
{
IsCubemap = reader.ReadBoolean();
}
if (IsReadMipMap(reader.Version))
{
MipMap = reader.ReadBoolean();
}
if (IsReadGenerateMips(reader.Version))
{
GenerateMips = reader.ReadBoolean();
}
if (IsReadSRGB(reader.Version))
{
SRGB = reader.ReadBoolean();
}
if (IsReadUseDynamicScale(reader.Version))
{
UseDynamicScale = reader.ReadBoolean();
BindMS = reader.ReadBoolean();
}
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
TextureSettings.Read(reader);
if (IsReadDimension(reader.Version))
{
Dimension = reader.ReadInt32();
VolumeDepth = reader.ReadInt32();
}
}
private static IEnumerable <TestCaseData> GenerateSpriteTestCases()
{
var buffer = new Color32[64 * 64];
var settings = new TextureSettings();
var alphaSettingsFromInput = new TextureAlphaSettings();
alphaSettingsFromInput.alphaSource = TextureImporterAlphaSource.FromInput;
var alphaSettingsFromGrayScale = new TextureAlphaSettings();
alphaSettingsFromGrayScale.alphaSource = TextureImporterAlphaSource.FromGrayScale;
var alphaSettingsNone = new TextureAlphaSettings();
alphaSettingsNone.alphaSource = TextureImporterAlphaSource.None;
var platformSettings = new TextureImporterPlatformSettings();
var platformSettingsOverride = new TextureImporterPlatformSettings();
platformSettingsOverride.overridden = true;
platformSettingsOverride.maxTextureSize = 32;
var spriteSettings = new TextureSpriteSettings();
var spriteSettingsWithSprites = new TextureSpriteSettings();
spriteSettingsWithSprites.spriteSheetData = new SpriteImportData[]
{
new SpriteImportData()
{
name = "Sprite1",
rect = new Rect(0, 0, 32, 32),
spriteID = GUID.Generate().ToString()
},
new SpriteImportData()
{
name = "Sprite2",
rect = new Rect(32, 32, 32, 32),
spriteID = GUID.Generate().ToString()
},
new SpriteImportData()
{
name = "Sprite3",
rect = new Rect(0, 32, 32, 32),
spriteID = GUID.Generate().ToString()
},
};
{
GenerateSpriteTestCase testCase = new GenerateSpriteTestCase
{
settings = settings,
platformSettings = platformSettings,
spriteSettings = spriteSettings,
bufferWidth = 64,
bufferHeight = 64,
buffer = buffer,
testName = "GenerateSpriteWithNoSpriteData"
};
yield return(new TestCaseData(testCase));
testCase.spriteSettings = spriteSettingsWithSprites;
testCase.testName = "GenerateSpriteWithSpriteData";
yield return(new TestCaseData(testCase));
}
{
GenerateSpriteTestCase testCase = new GenerateSpriteTestCase
{
settings = settings,
platformSettings = platformSettings,
spriteSettings = spriteSettings,
bufferWidth = 64,
bufferHeight = 64,
buffer = buffer,
testName = "GenerateSpriteWithNoSpriteData_AlphaNone",
alphaSettings = alphaSettingsNone
};
yield return(new TestCaseData(testCase));
testCase.testName = "GenerateSpriteWithSpriteData_AlphaNone";
testCase.spriteSettings = spriteSettingsWithSprites;
yield return(new TestCaseData(testCase));
}
{
GenerateSpriteTestCase testCase = new GenerateSpriteTestCase
{
settings = settings,
platformSettings = platformSettings,
spriteSettings = spriteSettings,
bufferWidth = 64,
bufferHeight = 64,
buffer = buffer,
testName = "GenerateSpriteWithNoSpriteData_AlphaGrayScale",
alphaSettings = alphaSettingsFromGrayScale
};
yield return(new TestCaseData(testCase));
testCase.testName = "GenerateSpriteWithSpriteData_AlphaGrayScale";
testCase.spriteSettings = spriteSettingsWithSprites;
yield return(new TestCaseData(testCase));
}
{
GenerateSpriteTestCase testCase = new GenerateSpriteTestCase
{
settings = settings,
platformSettings = platformSettings,
spriteSettings = spriteSettings,
bufferWidth = 64,
bufferHeight = 64,
buffer = buffer,
testName = "GenerateSpriteWithNoSpriteData_AlphaFromInput",
alphaSettings = alphaSettingsFromInput
};
yield return(new TestCaseData(testCase));
testCase.testName = "GenerateSpriteWithSpriteData_AlphaFromInput";
testCase.spriteSettings = spriteSettingsWithSprites;
yield return(new TestCaseData(testCase));
}
{
GenerateSpriteTestCase testCase = new GenerateSpriteTestCase
{
settings = settings,
platformSettings = platformSettingsOverride,
spriteSettings = spriteSettings,
bufferWidth = 64,
bufferHeight = 64,
buffer = buffer,
testName = "GenerateSpriteWithNoSpriteData_WithPlatformOverride",
alphaSettings = alphaSettingsFromInput
};
yield return(new TestCaseData(testCase));
testCase.testName = "GenerateSpriteWithSpriteData_WithPlatformOverride";
testCase.spriteSettings = spriteSettingsWithSprites;
yield return(new TestCaseData(testCase));
}
}
// TODO: We should rather put the texture settings in LightLoop, but how do we serialize it ?
public virtual void Build(TextureSettings textureSettings)
{
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
YAMLMappingNode mipmap = new YAMLMappingNode();
mipmap.Add(MipMapModeName, (int)MipMapMode);
mipmap.Add(EnableMipMapName, EnableMipMap);
if (HasSRGBTexture(container.ExportVersion))
{
mipmap.Add(SRGBTextureName, SRGBTexture);
}
if (HasLinearTexture(container.ExportVersion))
{
mipmap.Add(LinearTextureName, LinearTexture);
}
if (HasCorrectGamma(container.ExportVersion))
{
mipmap.Add(CorrectGammaName, CorrectGamma);
}
mipmap.Add(FadeOutName, FadeOut);
mipmap.Add(BorderMipMapName, BorderMipMap);
if (HasMipMapsPreserveCoverage(container.ExportVersion))
{
mipmap.Add(MipMapsPreserveCoverageName, MipMapsPreserveCoverage);
mipmap.Add(AlphaTestReferenceValueName, AlphaTestReferenceValue);
}
mipmap.Add(MipMapFadeDistanceStartName, MipMapFadeDistanceStart);
mipmap.Add(MipMapFadeDistanceEndName, MipMapFadeDistanceEnd);
node.Add(MipmapsName, mipmap);
YAMLMappingNode bumpmap = new YAMLMappingNode();
bumpmap.Add(ConvertToNormalMapName, ConvertToNormalMap);
if (HasExternalNormalMap(container.ExportVersion))
{
bumpmap.Add(ExternalNormalMapName, ExternalNormalMap);
}
bumpmap.Add(HeightScaleName, HeightScale);
bumpmap.Add(NormalMapFilterName, (int)NormalMapFilter);
node.Add(BumpmapName, bumpmap);
if (HasIsReadable(container.ExportVersion))
{
node.Add(IsReadableName, IsReadable);
}
if (HasStreamingMipmaps(container.ExportVersion))
{
node.Add(StreamingMipmapsName, StreamingMipmaps);
node.Add(StreamingMipmapsPriorityName, StreamingMipmapsPriority);
}
node.Add(GrayScaleToAlphaName, GrayScaleToAlpha);
node.Add(GenerateCubemapName, (int)GenerateCubemap);
if (HasCubemapConvolution(container.ExportVersion))
{
node.Add(CubemapConvolutionName, CubemapConvolution);
}
if (HasCubemapConvolutionSteps(container.ExportVersion))
{
node.Add(CubemapConvolutionStepsName, CubemapConvolutionSteps);
node.Add(CubemapConvolutionExponentName, CubemapConvolutionExponent);
}
if (HasSeamlessCubemap(container.ExportVersion))
{
node.Add(SeamlessCubemapName, SeamlessCubemap);
}
node.Add(TextureFormatName, (int)TextureFormat);
if (HasRecommendedTextureFormat(container.ExportVersion) && RecommendedTextureFormatFirst(container.ExportVersion))
{
node.Add(RecommendedTextureFormatName, RecommendedTextureFormat);
}
node.Add(MaxTextureSizeName, MaxTextureSize);
node.Add(TextureSettingsName, TextureSettings.ExportYAML(container));
node.Add(NPOTScaleName, (int)NPOTScale);
if (HasLightmap(container.ExportVersion))
{
node.Add(LightmapName, Lightmap);
}
if (HasRGBM(container.ExportVersion))
{
node.Add(RGBMName, RGBM);
}
if (HasCompressionQuality(container.ExportVersion))
{
node.Add(CompressionQualityName, CompressionQuality);
}
if (HasAllowsAlphaSplitting(container.ExportVersion))
{
node.Add(AllowsAlphaSplittingName, AllowsAlphaSplitting);
}
if (HasSprite(container.ExportVersion))
{
node.Add(SpriteModeName, (int)SpriteMode);
node.Add(SpriteExtrudeName, SpriteExtrude);
node.Add(SpriteMeshTypeName, (int)SpriteMeshType);
node.Add(AlignmentName, (int)Alignment);
node.Add(SpritePivotName, SpritePivot.ExportYAML(container));
}
if (HasSprite(container.ExportVersion) && SpritePixelsToUnitsFirst(container.ExportVersion))
{
node.Add(SpritePixelsToUnitsName, SpritePixelsToUnits);
}
if (HasSpriteBorder(container.ExportVersion))
{
node.Add(SpriteBorderName, SpriteBorder.ExportYAML(container));
}
if (HasSprite(container.ExportVersion) && !SpritePixelsToUnitsFirst(container.ExportVersion))
{
node.Add(SpritePixelsToUnitsName, SpritePixelsToUnits);
}
if (HasSpriteGenerateFallbackPhysicsShape(container.ExportVersion))
{
node.Add(SpriteGenerateFallbackPhysicsShapeName, SpriteGenerateFallbackPhysicsShape);
}
if (HasAlphaUsage(container.ExportVersion))
{
node.Add(AlphaUsageName, (int)AlphaUsage);
}
if (HasAlphaIsTransparency(container.ExportVersion))
{
node.Add(AlphaIsTransparencyName, AlphaIsTransparency);
}
if (HasSpriteTessellationDetail(container.ExportVersion))
{
node.Add(SpriteTessellationDetailName, SpriteTessellationDetail);
}
if (HasTextureType(container.ExportVersion))
{
node.Add(TextureTypeName, (int)TextureType);
}
if (HasRecommendedTextureFormat(container.ExportVersion) && !RecommendedTextureFormatFirst(container.ExportVersion))
{
node.Add(RecommendedTextureFormatName, RecommendedTextureFormat);
}
if (HasSourceTextureInformation(container.ExportVersion))
{
node.Add(SourceTextureInformationName, SourceTextureInformation.ExportYAML(container));
}
if (HasTextureShape(container.ExportVersion))
{
node.Add(TextureShapeName, (int)TextureShape);
}
if (HasSingleChannelComponent(container.ExportVersion))
{
node.Add(SingleChannelComponentName, SingleChannelComponent);
}
if (HasMaxTextureSizeSet(container.ExportVersion))
{
node.Add(MaxTextureSizeSetName, MaxTextureSizeSet);
node.Add(CompressionQualitySetName, CompressionQualitySet);
node.Add(TextureFormatSetName, TextureFormatSet);
}
if (HasPlatformSettings(container.ExportVersion))
{
node.Add(GetPlatformSettingsName(container.ExportVersion), PlatformSettings.ExportYAML(container));
}
if (HasSprite(container.ExportVersion))
{
node.Add(SpriteSheetName, SpriteSheet.ExportYAML(container));
node.Add(SpritePackingTagName, SpritePackingTag);
}
/*if (HasOutput(container.ExportVersion))
* {
* node.Add(OutputName, Output.ExportYAML(container));
* }*/
if (HasPSDRemoveMatte(container.ExportVersion))
{
node.Add(PSDRemoveMatteName, PSDRemoveMatte);
node.Add(PSDShowRemoveMatteOptionName, PSDShowRemoveMatteOption);
}
PostExportYAML(container, node);
return(node);
}
public override void Write(AssetWriter writer)
{
base.Write(writer);
bool isBoolFlags = IsBoolFlags(writer.Version);
writer.Write((int)MipMapMode);
if (isBoolFlags)
{
writer.Write(EnableMipMapBool);
writer.Write(CorrectGammaBool);
writer.Write(FadeOutBool);
writer.Write(BorderMipMapBool);
}
else
{
writer.Write(EnableMipMap);
if (HasSRGBTexture(writer.Version))
{
writer.Write(SRGBTexture);
}
if (HasLinearTexture(writer.Version))
{
writer.Write(LinearTexture);
}
if (HasCorrectGamma(writer.Version))
{
writer.Write(CorrectGamma);
}
writer.Write(FadeOut);
writer.Write(BorderMipMap);
}
if (HasMipMapsPreserveCoverage(writer.Version))
{
writer.Write(MipMapsPreserveCoverage);
writer.Write(AlphaTestReferenceValue);
}
writer.Write(MipMapFadeDistanceStart);
writer.Write(MipMapFadeDistanceEnd);
if (isBoolFlags)
{
writer.Write(ConvertToNormalMapBool);
if (HasIsReadable(writer.Version))
{
writer.Write(IsReadableBool);
}
}
else
{
writer.Write(ConvertToNormalMap);
writer.Write(ExternalNormalMap);
if (IsReadableFirst(writer.Version))
{
writer.Write(IsReadable);
writer.AlignStream();
}
}
writer.Write(HeightScale);
writer.Write((int)NormalMapFilter);
if (!IsReadableFirst(writer.Version))
{
writer.Write(IsReadable);
}
if (HasStreamingMipmaps(writer.Version))
{
writer.Write(StreamingMipmaps);
writer.Write(StreamingMipmapsPriority);
}
if (isBoolFlags)
{
writer.Write(GrayScaleToAlphaBool);
}
else
{
writer.Write(GrayScaleToAlpha);
}
if (IsAlignGrayScaleToAlpha(writer.Version))
{
writer.AlignStream();
}
writer.Write((int)GenerateCubemap);
if (HasCubemapConvolution(writer.Version))
{
writer.Write(CubemapConvolution);
}
if (HasCubemapConvolutionSteps(writer.Version))
{
writer.Write(CubemapConvolutionSteps);
writer.Write(CubemapConvolutionExponent);
}
if (HasSeamlessCubemap(writer.Version))
{
writer.Write(SeamlessCubemap);
}
writer.Write((int)TextureFormat);
if (IsAlignTextureFormat(writer.Version))
{
writer.AlignStream();
}
if (HasRecommendedTextureFormat(writer.Version) && RecommendedTextureFormatFirst(writer.Version))
{
writer.Write(RecommendedTextureFormat);
writer.AlignStream();
}
writer.Write(MaxTextureSize);
TextureSettings.Write(writer);
writer.Write((int)NPOTScale);
if (HasLightmap(writer.Version))
{
writer.Write(Lightmap);
}
if (HasRGBM(writer.Version))
{
writer.Write(RGBM);
}
if (HasCompressionQuality(writer.Version))
{
writer.Write(CompressionQuality);
}
if (HasAllowsAlphaSplitting(writer.Version))
{
writer.Write(AllowsAlphaSplitting);
writer.AlignStream();
}
if (HasSprite(writer.Version))
{
writer.Write((int)SpriteMode);
writer.Write(SpriteExtrude);
writer.Write((int)SpriteMeshType);
writer.Write((int)Alignment);
SpritePivot.Write(writer);
}
if (HasSprite(writer.Version) && SpritePixelsToUnitsFirst(writer.Version))
{
writer.Write(SpritePixelsToUnits);
}
if (HasSpriteBorder(writer.Version))
{
SpriteBorder.Write(writer);
}
if (HasSprite(writer.Version) && !SpritePixelsToUnitsFirst(writer.Version))
{
writer.Write(SpritePixelsToUnits);
}
if (HasSpriteGenerateFallbackPhysicsShape(writer.Version))
{
writer.Write(SpriteGenerateFallbackPhysicsShape);
}
if (HasAlphaUsage(writer.Version))
{
writer.Write((int)AlphaUsage);
}
if (HasAlphaIsTransparency(writer.Version))
{
writer.Write(AlphaIsTransparency);
}
if (HasSpriteTessellationDetail(writer.Version))
{
writer.Write(SpriteTessellationDetail);
}
if (HasTextureType(writer.Version))
{
writer.Write((int)TextureType);
}
if (HasRecommendedTextureFormat(writer.Version) && !RecommendedTextureFormatFirst(writer.Version))
{
writer.Write(RecommendedTextureFormat);
}
if (HasSourceTextureInformation(writer.Version))
{
SourceTextureInformation.Write(writer);
writer.AlignStream();
}
if (HasTextureShape(writer.Version))
{
writer.Write((int)TextureShape);
}
if (HasSingleChannelComponent(writer.Version))
{
writer.Write(SingleChannelComponent);
}
if (HasMaxTextureSizeSet(writer.Version))
{
writer.Write(MaxTextureSizeSet);
writer.Write(CompressionQualitySet);
writer.Write(TextureFormatSet);
}
writer.AlignStream();
if (HasPlatformSettings(writer.Version))
{
PlatformSettings.Write(writer);
}
if (HasSprite(writer.Version))
{
SpriteSheet.Write(writer);
writer.Write(SpritePackingTag);
}
if (HasOutput(writer.Version))
{
Output.Write(writer);
}
if (HasPSDRemoveMatte(writer.Version))
{
writer.Write(PSDRemoveMatte);
writer.Write(PSDShowRemoveMatteOption);
}
writer.AlignStream();
PostWrite(writer);
}
public override void Read(AssetReader reader)
{
base.Read(reader);
#if UNIVERSAL
if (IsReadAlphaIsTransparency(reader.Version, reader.Flags))
{
if (GetAlphaIsTransparencyPosition(reader.Version) == 0)
{
AlphaIsTransparency = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
}
#endif
Width = reader.ReadInt32();
Height = reader.ReadInt32();
CompleteImageSize = reader.ReadInt32();
TextureFormat = (TextureFormat)reader.ReadInt32();
if (IsBoolMinMap(reader.Version))
{
bool mipMap = reader.ReadBoolean();
if (mipMap)
{
int maxSide = Math.Max(Width, Height);
MipCount = Convert.ToInt32(Math.Log(maxSide) / Math.Log(2));
}
else
{
MipCount = 1;
}
}
else
{
MipCount = reader.ReadInt32();
}
if (IsReadIsReadable(reader.Version))
{
IsReadable = reader.ReadBoolean();
}
if (IsReadReadAllowed(reader.Version))
{
ReadAllowed = reader.ReadBoolean();
}
if (IsReadStreamingMipmaps(reader.Version))
{
StreamingMipmaps = reader.ReadBoolean();
}
#if UNIVERSAL
if (IsReadAlphaIsTransparency(reader.Version, reader.Flags))
{
if (GetAlphaIsTransparencyPosition(reader.Version) == 1)
{
AlphaIsTransparency = reader.ReadBoolean();
}
}
#endif
reader.AlignStream(AlignType.Align4);
if (IsReadStreamingMipmapsPriority(reader.Version))
{
StreamingMipmapsPriority = reader.ReadInt32();
#if UNIVERSAL
if (IsReadAlphaIsTransparency(reader.Version, reader.Flags))
{
if (GetAlphaIsTransparencyPosition(reader.Version) == 2)
{
AlphaIsTransparency = reader.ReadBoolean();
}
}
#endif
reader.AlignStream(AlignType.Align4);
}
ImageCount = reader.ReadInt32();
TextureDimension = (TextureDimension)reader.ReadInt32();
TextureSettings.Read(reader);
if (IsReadLightmapFormat(reader.Version))
{
LightmapFormat = (TextureUsageMode)reader.ReadInt32();
}
if (IsReadColorSpace(reader.Version))
{
ColorSpace = (ColorSpace)reader.ReadInt32();
}
m_imageData = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
if (IsReadStreamData(reader.Version))
{
StreamData.Read(reader);
}
}
/* Given a list of textures and settings, copy over each texture into a texture2darray and save it as a file **/
private void CopyListIntoArray(TextureList List, TextureSettings Settings)
{
if (List != null && List.TexArray.Length > 0)
{
if (List.TexArray[0] == null)
{
EditorUtility.DisplayDialog("First element unassigned", "Element 0 of the texture list is empty!",
"ok");
return;
}
Texture2DArray output = new Texture2DArray(List.TexArray[0].width, List.TexArray[0].height,
List.TexArray.Length, List.TexArray[0].format, Settings.copyMips);
output.mipMapBias = Settings.mipMapBias;
output.filterMode = Settings.filterMode;
output.wrapModeU = Settings.wrapModeU;
output.wrapModeV = Settings.wrapModeV;
output.anisoLevel = Settings.anisoLevel;
bool consistentSettings = true;
for (int i = 0; i < List.TexArray.Length; i++)
{
/* Stop if one of the elements in the list is empty **/
if (List.TexArray[i] == null)
{
EditorUtility.DisplayDialog("Element unassigned",
string.Format("Element {0} of the texture list is empty!", i), "ok");
return;
}
/* Stop if the texture being copied doesn't have the same settings as the first element of the array **/
consistentSettings = HasSameSettings(List.TexArray[0], List.TexArray[i], i);
if (consistentSettings == false)
{
return;
}
/* Copy the contents of the texture into the corresponding slice of the Texture2DArray, and copy over all the mips if copyMips is true **/
if (Settings.copyMips)
{
for (int j = 0; j < List.TexArray[0].mipmapCount; j++)
{
Graphics.CopyTexture(List.TexArray[i], 0, j, output, i, j);
}
}
else
{
Graphics.CopyTexture(List.TexArray[i], 0, 0, output, i, 0);
}
}
output.Apply(false);
string path = EditorUtility.SaveFilePanelInProject("Save Array", List.name + "_texarray.asset", "asset",
"Please enter a file name to save the texture array to");
if (path.Length != 0)
{
AssetDatabase.CreateAsset(output, path);
}
}
else
{
EditorUtility.DisplayDialog("No texture list selected", "You must enter a non-empty texture list",
"ok");
}
}
public TextureImportSettings(TextureSettings settings)
{
m_textureSettings = settings;
}
public override void Read(AssetReader reader)
{
base.Read(reader);
bool isBoolFlags = IsBoolFlags(reader.Version);
MipMapMode = (TextureImporterMipFilter)reader.ReadInt32();
if (isBoolFlags)
{
EnableMipMapBool = reader.ReadBoolean();
CorrectGammaBool = reader.ReadBoolean();
FadeOutBool = reader.ReadBoolean();
BorderMipMapBool = reader.ReadBoolean();
}
else
{
EnableMipMap = reader.ReadInt32();
if (HasSRGBTexture(reader.Version))
{
SRGBTexture = reader.ReadInt32();
}
if (HasLinearTexture(reader.Version))
{
LinearTexture = reader.ReadInt32();
}
if (HasCorrectGamma(reader.Version))
{
CorrectGamma = reader.ReadInt32();
}
FadeOut = reader.ReadInt32();
BorderMipMap = reader.ReadInt32();
}
if (HasMipMapsPreserveCoverage(reader.Version))
{
MipMapsPreserveCoverage = reader.ReadInt32();
AlphaTestReferenceValue = reader.ReadSingle();
}
MipMapFadeDistanceStart = reader.ReadInt32();
MipMapFadeDistanceEnd = reader.ReadInt32();
if (isBoolFlags)
{
ConvertToNormalMapBool = reader.ReadBoolean();
if (HasIsReadable(reader.Version))
{
IsReadableBool = reader.ReadBoolean();
}
}
else
{
ConvertToNormalMap = reader.ReadInt32();
ExternalNormalMap = reader.ReadInt32();
if (IsReadableFirst(reader.Version))
{
IsReadable = reader.ReadInt32();
reader.AlignStream();
}
}
HeightScale = reader.ReadSingle();
NormalMapFilter = (TextureImporterNormalFilter)reader.ReadInt32();
if (!IsReadableFirst(reader.Version))
{
IsReadable = reader.ReadInt32();
}
if (HasStreamingMipmaps(reader.Version))
{
StreamingMipmaps = reader.ReadInt32();
StreamingMipmapsPriority = reader.ReadInt32();
}
if (isBoolFlags)
{
GrayScaleToAlphaBool = reader.ReadBoolean();
}
else
{
GrayScaleToAlpha = reader.ReadInt32();
}
if (IsAlignGrayScaleToAlpha(reader.Version))
{
reader.AlignStream();
}
GenerateCubemap = (TextureImporterGenerateCubemap)reader.ReadInt32();
if (HasCubemapConvolution(reader.Version))
{
CubemapConvolution = reader.ReadInt32();
}
if (HasCubemapConvolutionSteps(reader.Version))
{
CubemapConvolutionSteps = reader.ReadInt32();
CubemapConvolutionExponent = reader.ReadSingle();
}
if (HasSeamlessCubemap(reader.Version))
{
SeamlessCubemap = reader.ReadInt32();
}
TextureFormat = (TextureFormat)reader.ReadInt32();
if (IsAlignTextureFormat(reader.Version))
{
reader.AlignStream();
}
if (HasRecommendedTextureFormat(reader.Version) && RecommendedTextureFormatFirst(reader.Version))
{
RecommendedTextureFormat = reader.ReadInt32();
reader.AlignStream();
}
MaxTextureSize = reader.ReadInt32();
TextureSettings.Read(reader);
NPOTScale = (TextureImporterNPOTScale)reader.ReadInt32();
if (HasLightmap(reader.Version))
{
Lightmap = reader.ReadInt32();
}
if (HasRGBM(reader.Version))
{
RGBM = reader.ReadInt32();
}
if (HasCompressionQuality(reader.Version))
{
CompressionQuality = reader.ReadInt32();
}
if (HasAllowsAlphaSplitting(reader.Version))
{
AllowsAlphaSplitting = reader.ReadInt32();
reader.AlignStream();
}
if (HasSprite(reader.Version))
{
SpriteMode = (SpriteImportMode)reader.ReadInt32();
SpriteExtrude = reader.ReadUInt32();
SpriteMeshType = (SpriteMeshType)reader.ReadInt32();
Alignment = (SpriteAlignment)reader.ReadInt32();
SpritePivot.Read(reader);
}
if (HasSprite(reader.Version) && SpritePixelsToUnitsFirst(reader.Version))
{
SpritePixelsToUnits = reader.ReadSingle();
}
if (HasSpriteBorder(reader.Version))
{
SpriteBorder.Read(reader);
}
if (HasSprite(reader.Version) && !SpritePixelsToUnitsFirst(reader.Version))
{
SpritePixelsToUnits = reader.ReadSingle();
}
if (HasSpriteGenerateFallbackPhysicsShape(reader.Version))
{
SpriteGenerateFallbackPhysicsShape = reader.ReadInt32();
}
if (HasAlphaUsage(reader.Version))
{
AlphaUsage = (TextureImporterAlphaSource)reader.ReadInt32();
}
if (HasAlphaIsTransparency(reader.Version))
{
AlphaIsTransparency = reader.ReadInt32();
}
if (HasSpriteTessellationDetail(reader.Version))
{
SpriteTessellationDetail = reader.ReadSingle();
}
if (HasTextureType(reader.Version))
{
TextureType = (TextureImporterType)reader.ReadInt32();
}
if (HasRecommendedTextureFormat(reader.Version) && !RecommendedTextureFormatFirst(reader.Version))
{
RecommendedTextureFormat = reader.ReadInt32();
}
if (HasSourceTextureInformation(reader.Version))
{
SourceTextureInformation = reader.ReadAsset <SourceTextureInformation>();
reader.AlignStream();
}
if (HasTextureShape(reader.Version))
{
TextureShape = (TextureImporterShape)reader.ReadInt32();
}
if (HasSingleChannelComponent(reader.Version))
{
SingleChannelComponent = reader.ReadInt32();
}
if (HasMaxTextureSizeSet(reader.Version))
{
MaxTextureSizeSet = reader.ReadInt32();
CompressionQualitySet = reader.ReadInt32();
TextureFormatSet = reader.ReadInt32();
}
reader.AlignStream();
if (HasPlatformSettings(reader.Version))
{
PlatformSettings = reader.ReadAssetArray <TextureImporterPlatformSettings>();
}
if (HasSprite(reader.Version))
{
SpriteSheet.Read(reader);
SpritePackingTag = reader.ReadString();
}
if (HasOutput(reader.Version))
{
Output.Read(reader);
}
if (HasPSDRemoveMatte(reader.Version))
{
PSDRemoveMatte = reader.ReadBoolean();
PSDShowRemoveMatteOption = reader.ReadBoolean();
}
reader.AlignStream();
PostRead(reader);
}
// Called with new atlas. Guesses the appropriate transparency type for
// the atlas and select the shader based on this.
private void PrepNewTexture()
{
if (!AutoOptimizeImages && !AutoGuessTransparency && !AutoGuessLayout)
{
return;
}
// Grab values to check against
var atlas = Atlas as Texture2D;
if (atlas == null)
{
return;
}
if (GetComponent <Renderer>() == null)
{
return;
}
Material material = GetComponent <Renderer>().sharedMaterial;
if (material == null)
{
return;
}
TextureSettings.AddTemporaryReadableToTexture(atlas);
// Optimize texture properties
if (AutoOptimizeImages)
{
TextureSettings.SetAtlasAsOptimalForBbSprite(Atlas);
}
// Determine which shader to use
if (AutoGuessTransparency)
{
if (atlas.GetPixel(0, 0).a != 1)
{
material.shader = Shader.Find("Sprites/BbSprites/Alpha");
}
else
{
Shader defaultColorShader =
Shader.Find("Sprites/BbSprites/ColorKey_UL");
if (
material.shader != defaultColorShader &&
material.shader !=
Shader.Find("Sprites/BbSprites/ColorKey_UR") &&
material.shader !=
Shader.Find("Sprites/BbSprites/ColorKey_LL") &&
material.shader !=
Shader.Find("Sprites/BbSprites/ColorKey_LR") &&
material.shader !=
Shader.Find("Sprites/BbSprites/ColorKey_Custom"))
{
material.shader = defaultColorShader;
}
}
}
// Determine which layout type to use
if (AutoGuessLayout)
{
var layout = GetComponent <BbSpriteLayout>();
if (layout == null)
{
return;
}
var width = atlas.width;
var hasKeyColor =
(material.shader != Shader.Find("Sprites/BbSprites/Alpha"));
// check for rpgmaker
if (
!TextureSettings.CheckTextureColumnForOpacity(
atlas, (int)(width * .33333f), hasKeyColor) &&
!TextureSettings.CheckTextureColumnForOpacity(
atlas, (int)(width * .66666f), hasKeyColor)
)
{
layout.MyType = BbSpriteLayout.Type.RpgMaker;
layout.Update();
}
// check for 4 by 4
else if (
!TextureSettings.CheckTextureColumnForOpacity(
atlas, (int)(width * .5f), hasKeyColor) &&
!TextureSettings.CheckTextureColumnForOpacity(
atlas, (int)(width * .25f), hasKeyColor) &&
!TextureSettings.CheckTextureColumnForOpacity(
atlas, (int)(width * .75f), hasKeyColor)
)
{
layout.MyType = BbSpriteLayout.Type.FourByFour;
layout.Update();
}
// If failed other checks, is single cell
else
{
layout.MyType = BbSpriteLayout.Type.SingleCell;
layout.Update();
}
}
TextureSettings.RemoveTemporaryReadableFromTexture(atlas);
}
