private void DisplayNormalAlphaFromGrayscaleSettings()
{
createAlphaFromGrayscale = EditorGUILayout.Toggle("Create from Grayscale", createAlphaFromGrayscale);
if (createAlphaFromGrayscale)
{
EditorGUI.indentLevel++;
bumpiness = EditorGUILayout.Slider("Bumpiness", bumpiness, 0.0f, 0.3f);
normalBumpFiltering = (TextureImporterNormalFilter)EditorGUILayout.EnumPopup("Filtering", normalBumpFiltering);
EditorGUI.indentLevel--;
}
}
public override void ReadFromAsset(Object asset)
{
if (!(asset is Texture2D))
{
Debug.Log("Asset isn't a Texture2D. Can't read from asset");
return;
}
Texture2D texture = asset as Texture2D;
name = texture.name;
TextureImporter textureImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(texture)) as TextureImporter;
if (textureImporter == null)
{
Debug.Log("Could not get texture importer for asset at path: " + AssetDatabase.GetAssetPath(texture));
return;
}
guid = AssetDatabase.AssetPathToGUID(textureImporter.assetPath);
anisoLevel = textureImporter.anisoLevel;
borderMipmap = textureImporter.borderMipmap;
convertToNormalmap = textureImporter.convertToNormalmap;
generateMipsInLinearSpace = textureImporter.generateMipsInLinearSpace;
fadeout = textureImporter.fadeout;
filterMode = textureImporter.filterMode;
generateCubemap = textureImporter.generateCubemap;
grayscaleToAlpha = textureImporter.grayscaleToAlpha;
heightmapScale = textureImporter.heightmapScale;
isReadable = textureImporter.isReadable;
lightmap = textureImporter.lightmap;
maxTextureSize = textureImporter.maxTextureSize;
mipMapBias = textureImporter.mipMapBias;
mipmapEnabled = textureImporter.mipmapEnabled;
mipmapFadeDistanceEnd = textureImporter.mipmapFadeDistanceEnd;
mipmapFadeDistanceStart = textureImporter.mipmapFadeDistanceStart;
mipmapFilter = textureImporter.mipmapFilter;
normalmap = textureImporter.normalmap;
normalmapFilter = textureImporter.normalmapFilter;
npotScale = textureImporter.npotScale;
textureFormat = textureImporter.textureFormat;
textureType = textureImporter.textureType;
wrapMode = textureImporter.wrapMode;
}
public void Apply(TextureImporterSettings settings)
{
this.seamlessCubemap = settings.seamlessCubemap;
this.mipmapBias = settings.mipmapBias;
this.wrapMode = settings.wrapMode;
this.wrapModeU = settings.wrapModeU;
this.wrapModeV = settings.wrapModeV;
this.wrapModeW = settings.wrapModeW;
this.alphaIsTransparency = settings.alphaIsTransparency;
this.spriteMode = settings.spriteMode;
this.spritePixelsPerUnit = settings.spritePixelsPerUnit;
this.spriteTessellationDetail = settings.spriteTessellationDetail;
this.spriteExtrude = settings.spriteExtrude;
this.spriteMeshType = settings.spriteMeshType;
this.spriteAlignment = settings.spriteAlignment;
this.spritePivot = settings.spritePivot;
this.spriteBorder = settings.spriteBorder;
this.spriteGenerateFallbackPhysicsShape = settings.spriteGenerateFallbackPhysicsShape;
this.aniso = settings.aniso;
this.filterMode = settings.filterMode;
this.cubemapConvolution = settings.cubemapConvolution;
this.textureType = settings.textureType;
this.textureShape = settings.textureShape;
this.mipmapFilter = settings.mipmapFilter;
this.mipmapEnabled = settings.mipmapEnabled;
this.sRGBTexture = settings.sRGBTexture;
this.fadeOut = settings.fadeOut;
this.borderMipmap = settings.borderMipmap;
this.mipMapsPreserveCoverage = settings.mipMapsPreserveCoverage;
this.mipmapFadeDistanceStart = settings.mipmapFadeDistanceStart;
this.alphaTestReferenceValue = settings.alphaTestReferenceValue;
this.convertToNormalMap = settings.convertToNormalMap;
this.heightmapScale = settings.heightmapScale;
this.normalMapFilter = settings.normalMapFilter;
this.alphaSource = settings.alphaSource;
this.singleChannelComponent = settings.singleChannelComponent;
this.readable = settings.readable;
this.streamingMipmaps = settings.streamingMipmaps;
this.streamingMipmapsPriority = settings.streamingMipmapsPriority;
this.npotScale = settings.npotScale;
this.generateCubemap = settings.generateCubemap;
this.mipmapFadeDistanceEnd = settings.mipmapFadeDistanceEnd;
}
public TextureImportSettings()
{
textureFormat = TextureImporterFormat.AutomaticTruecolor;
maxTextureSize = (int)TextureSize.Unlimited;
grayscaleToAlpha = false;
generateCubemap = TextureImporterGenerateCubemap.None;
isReadable = false;
mipmapEnabled = true;
borderMipmap = false;
mipmapFilter = TextureImporterMipFilter.BoxFilter;
fadeout = false;
mipmapFadeDistanceStart = 1;
mipmapFadeDistanceEnd = 1;
generateMipsInLinearSpace = false;
normalmapFilter = TextureImporterNormalFilter.Standard;
heightmapScale = 0.25f;
anisoLevel = 1;
filterMode = FilterMode.Bilinear;
wrapMode = TextureWrapMode.Repeat;
textureType = TextureImporterType.Default;
}
public TextureNormalSettings(TextureImporterNormalFilter filter, bool generateFromGrayScale, float bumpiness)
{
this.filter = filter;
this.generateFromGrayScale = generateFromGrayScale;
this.bumpiness = bumpiness;
}
public override void ApplyCopiedValues(string[] properties, object[] values)
{
for (int i = 0; i < properties.Length; i++)
{
string property = properties[i];
if (property == "anisoLevel")
{
anisoLevel = (int)values[i];
}
if (property == "borderMipmap")
{
borderMipmap = (bool)values[i];
}
if (property == "convertToNormalmap")
{
convertToNormalmap = (bool)values[i];
}
if (property == "correctGamma")
{
generateMipsInLinearSpace = (bool)values[i];
}
if (property == "fadeout")
{
fadeout = (bool)values[i];
}
if (property == "filterMode")
{
filterMode = (FilterMode)values[i];
}
;
if (property == "generateCubemap")
{
generateCubemap = (TextureImporterGenerateCubemap)values[i];
}
if (property == "grayscaleToAlpha")
{
grayscaleToAlpha = (bool)values[i];
}
if (property == "heightmapScale")
{
heightmapScale = (float)values[i];
}
if (property == "isReadable")
{
isReadable = (bool)values[i];
}
if (property == "lightmap")
{
lightmap = (bool)values[i];
}
if (property == "maxTextureSize")
{
maxTextureSize = (int)values[i];
}
if (property == "mipMapBias")
{
mipMapBias = (float)values[i];
}
if (property == "mipmapEnabled")
{
mipmapEnabled = (bool)values[i];
}
if (property == "mipmapFadeDistanceEnd")
{
mipmapFadeDistanceEnd = (int)values[i];
}
if (property == "mipmapFadeDistanceStart")
{
mipmapFadeDistanceStart = (int)values[i];
}
if (property == "mipmapFilter")
{
mipmapFilter = (TextureImporterMipFilter)values[i];
}
if (property == "normalmap")
{
normalmap = (bool)values[i];
}
if (property == "normalmapFilter")
{
normalmapFilter = (TextureImporterNormalFilter)values[i];
}
if (property == "npotScale")
{
npotScale = (TextureImporterNPOTScale)values[i];
}
if (property == "textureFormat")
{
textureFormat = (TextureImporterFormat)values[i];
}
if (property == "textureType")
{
textureType = (TextureImporterType)values[i];
}
if (property == "wrapMode")
{
wrapMode = (TextureWrapMode)values[i];
}
}
}
public TextureAsset(StreamReader reader)
{
string line = string.Empty;
while ((line = reader.ReadLine()) != null)
{
if (line.Contains(VerySimpleXml.EndNode(nodeName)))
{
break;
}
//Name
if (line.Contains(VerySimpleXml.StartNode(nameNodeName)))
{
name = VerySimpleXml.NodeValue(line, nameNodeName);
}
//Path
if (line.Contains(VerySimpleXml.StartNode(pathNodeName)))
{
guid = AssetDatabase.AssetPathToGUID(VerySimpleXml.NodeValue(line, pathNodeName));
}
if (line.Contains(VerySimpleXml.StartNode(guidNodeName)))
{
guid = VerySimpleXml.NodeValue(line, guidNodeName);
}
//IMPORT SETTINGS
if (line.Contains(VerySimpleXml.StartNode("anisoLevel")))
{
anisoLevel = int.Parse(VerySimpleXml.NodeValue(line, "anisoLevel"));
}
if (line.Contains(VerySimpleXml.StartNode("borderMipmap")))
{
borderMipmap = bool.Parse(VerySimpleXml.NodeValue(line, "borderMipmap"));
}
if (line.Contains(VerySimpleXml.StartNode("convertToNormalmap")))
{
convertToNormalmap = bool.Parse(VerySimpleXml.NodeValue(line, "convertToNormalmap"));
}
if (line.Contains(VerySimpleXml.StartNode("correctGamma")))
{
generateMipsInLinearSpace = bool.Parse(VerySimpleXml.NodeValue(line, "correctGamma"));
}
if (line.Contains(VerySimpleXml.StartNode("fadeout")))
{
fadeout = bool.Parse(VerySimpleXml.NodeValue(line, "fadeout"));
}
if (line.Contains(VerySimpleXml.StartNode("filterMode")))
{
filterMode = (FilterMode)System.Enum.Parse(typeof(FilterMode), VerySimpleXml.NodeValue(line, "filterMode"));
}
if (line.Contains(VerySimpleXml.StartNode("generateCubemap")))
{
generateCubemap = (TextureImporterGenerateCubemap)System.Enum.Parse(typeof(TextureImporterGenerateCubemap), VerySimpleXml.NodeValue(line, "generateCubemap"));
}
if (line.Contains(VerySimpleXml.StartNode("grayscaleToAlpha")))
{
grayscaleToAlpha = bool.Parse(VerySimpleXml.NodeValue(line, "grayscaleToAlpha"));
}
if (line.Contains(VerySimpleXml.StartNode("heightmapScale")))
{
heightmapScale = float.Parse(VerySimpleXml.NodeValue(line, "heightmapScale"));
}
if (line.Contains(VerySimpleXml.StartNode("isReadable")))
{
isReadable = bool.Parse(VerySimpleXml.NodeValue(line, "isReadable"));
}
if (line.Contains(VerySimpleXml.StartNode("lightmap")))
{
lightmap = bool.Parse(VerySimpleXml.NodeValue(line, "lightmap"));
}
if (line.Contains(VerySimpleXml.StartNode("maxTextureSize")))
{
maxTextureSize = int.Parse(VerySimpleXml.NodeValue(line, "maxTextureSize"));
}
if (line.Contains(VerySimpleXml.StartNode("mipMapBias")))
{
mipMapBias = float.Parse(VerySimpleXml.NodeValue(line, "mipMapBias"));
}
if (line.Contains(VerySimpleXml.StartNode("mipmapEnabled")))
{
mipmapEnabled = bool.Parse(VerySimpleXml.NodeValue(line, "mipmapEnabled"));
}
if (line.Contains(VerySimpleXml.StartNode("mipmapFadeDistanceEnd")))
{
mipmapFadeDistanceEnd = int.Parse(VerySimpleXml.NodeValue(line, "mipmapFadeDistanceEnd"));
}
if (line.Contains(VerySimpleXml.StartNode("mipmapFadeDistanceStart")))
{
mipmapFadeDistanceStart = int.Parse(VerySimpleXml.NodeValue(line, "mipmapFadeDistanceStart"));
}
if (line.Contains(VerySimpleXml.StartNode("mipmapFilter")))
{
mipmapFilter = (TextureImporterMipFilter)System.Enum.Parse(typeof(TextureImporterMipFilter), VerySimpleXml.NodeValue(line, "mipmapFilter"));
}
if (line.Contains(VerySimpleXml.StartNode("normalmap")))
{
normalmap = bool.Parse(VerySimpleXml.NodeValue(line, "normalmap"));
}
if (line.Contains(VerySimpleXml.StartNode("normalmapFilter")))
{
normalmapFilter = (TextureImporterNormalFilter)System.Enum.Parse(typeof(TextureImporterNormalFilter), VerySimpleXml.NodeValue(line, "normalmapFilter"));
}
if (line.Contains(VerySimpleXml.StartNode("npotScale")))
{
npotScale = (TextureImporterNPOTScale)System.Enum.Parse(typeof(TextureImporterNPOTScale), VerySimpleXml.NodeValue(line, "npotScale"));
}
if (line.Contains(VerySimpleXml.StartNode("textureFormat")))
{
textureFormat = (TextureImporterFormat)System.Enum.Parse(typeof(TextureImporterFormat), VerySimpleXml.NodeValue(line, "textureFormat"));
}
if (line.Contains(VerySimpleXml.StartNode("textureType")))
{
textureType = (TextureImporterType)System.Enum.Parse(typeof(TextureImporterType), VerySimpleXml.NodeValue(line, "textureType"));
}
if (line.Contains(VerySimpleXml.StartNode("wrapMode")))
{
wrapMode = (TextureWrapMode)System.Enum.Parse(typeof(TextureWrapMode), VerySimpleXml.NodeValue(line, "wrapMode"));
}
}
}
public TextureImportSettings()
{
textureFormat = TextureImporterFormat.AutomaticTruecolor;
maxTextureSize = (int)TextureSize.Unlimited;
grayscaleToAlpha = false;
generateCubemap = TextureImporterGenerateCubemap.None;
isReadable = false;
mipmapEnabled = true;
borderMipmap = false;
mipmapFilter = TextureImporterMipFilter.BoxFilter;
fadeout = false;
mipmapFadeDistanceStart = 1;
mipmapFadeDistanceEnd = 1;
generateMipsInLinearSpace = false;
normalmapFilter = TextureImporterNormalFilter.Standard;
heightmapScale = 0.25f;
anisoLevel = 1;
filterMode = FilterMode.Bilinear;
wrapMode = TextureWrapMode.Repeat;
textureType = TextureImporterType.Image;
}
