/// <summary>
/// 从layer解析图片
/// </summary>
/// <param name="layer"></param>
/// <returns></returns>
public static Texture2D CreateTexture(PsdLayer layer)
{
Texture2D texture = new Texture2D(layer.Width, layer.Height);
Color32[] pixels = new Color32[layer.Width * layer.Height];
Channel red = Array.Find(layer.Channels, i => i.Type == ChannelType.Red);
Channel green = Array.Find(layer.Channels, i => i.Type == ChannelType.Green);
Channel blue = Array.Find(layer.Channels, i => i.Type == ChannelType.Blue);
Channel alpha = Array.Find(layer.Channels, i => i.Type == ChannelType.Alpha);
//Channel mask = Array.Find(layer.Channels, i => i.Type == ChannelType.Mask);
for (int i = 0; i < pixels.Length; i++)
{
byte r = red.Data[i];
byte g = green.Data[i];
byte b = blue.Data[i];
byte a = 255;
if (alpha != null)
{
a = alpha.Data[i];
}
//if (mask != null)
// a *= mask.Data[i];
int mod = i % texture.width;
int n = ((texture.width - mod - 1) + i) - mod;
pixels[pixels.Length - n - 1] = new Color32(r, g, b, a);
}
texture.SetPixels32(pixels);
texture.Apply();
return(texture);
}
/// <summary>
/// 转换为组
/// </summary>
/// <param name="layer"></param>
/// <param name="group"></param>
/// <param name="OnRetrive"></param>
public static void RetriveLayerToSwitchModle(Vector2 rootSize, PsdLayer layer, GroupNode group, bool forceSprite = false)
{
if (!layer.IsGroup)
{
return;
}
else
{
foreach (var child in layer.Childs)
{
if (child.IsGroup)
{
GroupNode childNode = group.InsertChild(GetRectFromLayer(child)).Analyzing(rouleObj, child.Name);
if (childNode != null)
{
group.groups.Add(childNode);
RetriveLayerToSwitchModle(rootSize, child, childNode, forceSprite);
}
}
else
{
ImgNode imgnode = AnalysisLayer(rootSize, child, forceSprite);
if (imgnode != null)
{
group.images.Add(imgnode);
}
}
}
}
}
protected override void ReadValue(PsdReader reader, object userData, out PsdLayer[] value)
{
PsdDocument document = userData as PsdDocument;
int layerCount = Math.Abs((int)reader.ReadInt16());
PsdLayer[] layers = new PsdLayer[layerCount];
for (int i = 0; i < layerCount; i++)
{
layers[i] = new PsdLayer(reader, document);
}
foreach (var item in layers)
{
item.ReadChannels(reader);
}
layers = Initialize(null, layers);
foreach (var item in layers.SelectMany(item => item.Descendants()).Reverse())
{
item.ComputeBounds();
}
value = layers;
}
private static Sprite ImportLayer(PsdDocument psdDoc, ImportUserData importSettings, ImportLayerData layerSettings, TextureImporterSettings psdUnityImport)
{
if (layerSettings == null)
{
return(null);
}
PsdLayer psdLayer = GetPsdLayerByIndex(psdDoc, layerSettings.indexId);
if (psdLayer.IsGroup)
{
return(null);
}
// Generate the texture
Texture2D layerTexture = GetLayerTexture(psdDoc, psdLayer, layerSettings);
if (layerTexture == null)
{
return(null);
}
// Save the texture as an asset
Sprite layerSprite = SaveAsset(psdLayer, psdUnityImport, layerTexture, importSettings, layerSettings);
return(layerSprite);
}
private static Sprite CreateSpriteAsset(PsdDocument psdDoc, ImportUserData importSettings, ImportLayerData layerSettings, TextureImporterSettings psdUnityImport)
{
if (layerSettings == null)
{
return(null);
}
PsdLayer psdLayer = GetPsdLayerByIndex(psdDoc, layerSettings.indexId);
if (psdLayer.IsGroup)
{
return(null);
}
// Generate the texture
Texture2D layerTexture = GetLayerTexture(psdDoc, psdLayer, layerSettings.ScaleFactor);
if (layerTexture == null)
{
return(null);
}
var layerPath = PathUtils.GetLayerPath(psdLayer, importSettings.fileNaming, importSettings.groupMode);
// Save the texture as an asset
return(SaveAsset(layerPath, psdUnityImport, layerTexture, importSettings.TargetDirectory, importSettings.PackingTag, layerSettings));
}
private static void AnalysisLayer(PsdLayer layer, LayerInfo layerInfo, List <LayerInfo> nodes)
{
if (layer.IsGroup)
{
var rect = GetRectFromLayer(layer);
var path = GetFullPath(layer);
var childLayerInfo = new LayerInfo()
{
name = layer.Name,
rect = rect,
path = path,
type = "RectTransform",
};
nodes.Add(childLayerInfo);
if (layer.Childs.Length > 0)
{
for (int i = 0; i < layer.Childs.Length; i++)
{
var child = layer.Childs[i];
AnalysisLayer(child, childLayerInfo, nodes);
}
}
}
else
{
AnalysisLayerInfo(layer, layerInfo);
}
}
private static object GetLayerFullName(PsdLayer layer)
{
var name = layer.Name;
var current = layer.Parent;
while (current != null)
{
name = current.Name + "_" + name;
current = current.Parent;
}
return(name);
}
private static void InitStrure(PsdLayer parent, Dictionary <PsdLayer, List <PsdLayer> > dic)
{
if (dic.ContainsKey(parent))
{
parent.Childs = dic[parent].ToArray();
foreach (var child in dic[parent])
{
child.Deepth = parent.Deepth + 1;
InitStrure(child, dic);
}
}
}
public static string GetFilePath(PsdLayer layer, ImportUserData importSettings, string format, out string dir)
{
string filename = string.Format("{0}.{1}", layer.Name, format);
string folder = "";
if (importSettings.fileNaming != NamingConvention.LayerNameOnly)
{
bool isDir = importSettings.fileNaming == NamingConvention.CreateGroupFolders;
var docLayer = layer.Document as IPsdLayer;
var parent = layer.Parent;
while (parent != null && parent.Equals(docLayer) == false)
{
if (isDir)
{
if (string.IsNullOrEmpty(folder))
{
folder = parent.Name;
}
else
{
folder = string.Format("{0}/{1}", parent.Name, folder);
}
}
else
{
filename = string.Format("{0}_{1}", parent.Name, filename);
}
parent = parent.Parent;
if (importSettings.groupMode == GroupMode.ParentOnly)
{
break;
}
}
}
string finalDir = importSettings.TargetDirectory;
if (string.IsNullOrEmpty(folder) == false)
{
finalDir = string.Format("{0}/{1}", finalDir, folder);
}
// Sanitize directory
finalDir = SanitizeString(finalDir, Path.GetInvalidPathChars());
// Sanitize filename
filename = SanitizeString(filename, Path.GetInvalidFileNameChars());
string filepath = string.Format("{0}/{1}", finalDir, filename);
dir = finalDir;
return(filepath);
}
protected override void ReadData(PsdReader reader, object userData)
{
PsdLayer layer = userData as PsdLayer;
LayerRecords records = layer.Records;
using (MemoryStream stream = new MemoryStream(reader.ReadBytes((int)this.Length)))
using (PsdReader r = new PsdReader(stream, reader.Resolver, reader.Uri))
{
r.Version = reader.Version;
this.ReadValue(r, layer.Depth, records.Channels);
}
Channels = records.Channels;
}
private static PfiLayer ProcessImageLayer(PsdDocument psd, PsdLayer psdLayer)
{
var layer = new PfiLayer(psdLayer.Name);
layer.texture = GetLayerTexture(psdLayer);
var x = psdLayer.Left + psdLayer.Width / 2;
var y = psd.Height - (psdLayer.Top + psdLayer.Height / 2);
x -= psd.Width / 2;
y -= psd.Height / 2;
layer.position = new Vector2(x, y);
return(layer);
}
private static Texture2D GetLayerTexture(PsdDocument psdDoc, PsdLayer psdLayer, ImportLayerData setting)
{
if (psdLayer == null || psdLayer.IsGroup)
{
return(null);
}
Texture2D layerTexture = GetTexture(psdLayer);
if (setting.ScaleFactor != ScaleFactor.Full)
{
int mipMapLevel = setting.ScaleFactor == ScaleFactor.Half ? 1 : 2;
layerTexture = ScaleTextureByMipmap(layerTexture, mipMapLevel);
}
return(layerTexture);
}
/// <summary>
/// 解析Layer中的尺寸信息
/// </summary>
/// <param name="psdLayer"></param>
/// <returns></returns>
private static Rect GetRectFromLayer(PsdLayer psdLayer)
{
//rootSize = new Vector2(rootSize.x > maxSize.x ? maxSize.x : rootSize.x, rootSize.y > maxSize.y ? maxSize.y : rootSize.y);
var left = psdLayer.Left; // psdLayer.Left <= 0 ? 0 : psdLayer.Left;
var bottom = psdLayer.Bottom; // psdLayer.Bottom <= 0 ? 0 : psdLayer.Bottom;
var top = psdLayer.Top; // psdLayer.Top >= rootSize.y ? rootSize.y : psdLayer.Top;
var rigtht = psdLayer.Right; // psdLayer.Right >= rootSize.x ? rootSize.x : psdLayer.Right;
var width = psdLayer.Width; // psdLayer.Width > rootSize.x ? rootSize.x : psdLayer.Width;
var height = psdLayer.Height; // psdLayer.Height > rootSize.y ? rootSize.y : psdLayer.Height;
var xMin = (rigtht + left - rootSize.x) * 0.5f;
var yMin = -(top + bottom - rootSize.y) * 0.5f;
return(new Rect(xMin, yMin, width, height));
}
/// <summary>
/// 计算layer的id
/// </summary>
/// <param name="layer"></param>
/// <returns></returns>
private static int CalcuteLayerID(PsdLayer layer)
{
int id = 0;
var parent = layer.Parent;
if (parent != null)
{
id = Array.IndexOf(parent.Childs, layer);
id += 10 * CalcuteLayerID(parent);
}
else
{
id = Array.IndexOf(layer.Document.Childs, layer);
}
return(id);
}
private static IEnumerator ParseLayers(IPsdLayer[] layers, bool doYield,
Action <PsdLayer, int[]> onLayer, Action onComplete, int[] parentIndex = null)
{
// Loop through layers in reverse so they are encountered in same order as Photoshop
for (int i = layers.Length - 1; i >= 0; i--)
{
int[] layerIndex = parentIndex;
if (layerIndex == null)
{
layerIndex = new int[] { i };
}
else
{
int lastIndex = layerIndex.Length;
Array.Resize(ref layerIndex, lastIndex + 1);
layerIndex[lastIndex] = i;
}
PsdLayer layer = layers[i] as PsdLayer;
if (layer == null)
{
continue;
}
if (onLayer != null)
{
onLayer(layer, layerIndex);
}
if (doYield)
{
yield return(null);
}
if (layer.Childs.Length > 0)
{
yield return(EditorCoroutineRunner.StartCoroutine(
ParseLayers(layer.Childs, doYield, onLayer, null, layerIndex)
));
}
}
if (onComplete != null)
{
onComplete();
}
}
/// <summary>
/// 从layer解析图片
/// </summary>
/// <param name="layer"></param>
/// <returns></returns>
public static Texture2D CreateTexture(PsdLayer layer)
{
Debug.Assert(layer.Width != 0 && layer.Height != 0, layer.Name + ": width = height = 0");
if (layer.Width == 0 || layer.Height == 0)
{
return(new Texture2D(layer.Width, layer.Height));
}
if (layer.Resources.Contains("lfx2"))
{
analysisError = true;
Debug.LogWarning(layer.Name + " 包含特效，本工具暂不支持解析，可将目标层转换为智能对象后重试！");
}
return(ChannelToTexture(layer.Width, layer.Height, layer.Channels));
}
private static PsdLayer GetPsdLayerByIndex(PsdDocument psdDoc, int[] layerIdx)
{
IPsdLayer target = psdDoc;
foreach (int idx in layerIdx)
{
if (idx < 0 || idx >= target.Childs.Length)
{
return(null);
}
target = target.Childs[idx];
}
PsdLayer layer = target as PsdLayer;
return(layer);
}
/// <summary>
/// 从layer解析图片
/// </summary>
/// <param name="layer"></param>
/// <returns></returns>
public static Texture2D CreateTexture(PsdLayer layer)
{
Debug.Assert(layer.Width != 0 && layer.Height != 0, layer.Name + ": width = height = 0");
if (layer.Width == 0 || layer.Height == 0)
{
return(new Texture2D(layer.Width, layer.Height));
}
Texture2D texture = new Texture2D(layer.Width, layer.Height);
Color32[] pixels = new Color32[layer.Width * layer.Height];
Channel red = Array.Find(layer.Channels, i => i.Type == ChannelType.Red);
Channel green = Array.Find(layer.Channels, i => i.Type == ChannelType.Green);
Channel blue = Array.Find(layer.Channels, i => i.Type == ChannelType.Blue);
Channel alpha = Array.Find(layer.Channels, i => i.Type == ChannelType.Alpha);
//Channel mask = Array.Find(layer.Channels, i => i.Type == ChannelType.Mask);
//if (layer.HasMask && alpha != null && alpha.Data != null)
//{
// Debug.Log(mask.Data.Length + ":" + alpha.Data.Length);
//}
for (int i = 0; i < pixels.Length; i++)
{
byte r = red.Data[i];
byte g = green.Data[i];
byte b = blue.Data[i];
byte a = 255;
if (alpha != null)
{
a = alpha.Data[i];
}
int mod = i % texture.width;
int n = ((texture.width - mod - 1) + i) - mod;
pixels[pixels.Length - n - 1] = new Color32(r, g, b, a);
}
texture.SetPixels32(pixels);
texture.Apply();
return(texture);
}
public static PsdLayer[] Initialize(PsdLayer parent, PsdLayer[] layers)
{
Stack <PsdLayer> stack = new Stack <PsdLayer>();
List <PsdLayer> rootLayers = new List <PsdLayer>();
Dictionary <PsdLayer, List <PsdLayer> > layerToChilds = new Dictionary <PsdLayer, List <PsdLayer> >();
foreach (var item in layers.Reverse())
{
if (item.SectionType == SectionType.Divider)
{
parent = stack.Pop();
continue;
}
if (parent != null)
{
if (layerToChilds.ContainsKey(parent) == false)
{
layerToChilds.Add(parent, new List <PsdLayer>());
}
List <PsdLayer> childs = layerToChilds[parent];
childs.Insert(0, item);
item.Parent = parent;
}
else
{
rootLayers.Insert(0, item);
}
if (item.SectionType == SectionType.Opend || item.SectionType == SectionType.Closed)
{
stack.Push(parent);
parent = item;
}
}
foreach (var item in rootLayers)
{
item.Deepth = 1;
InitStrure(item, layerToChilds);
}
return(rootLayers.ToArray());
}
private static void CreatePNGFile(PsdLayer layer)
{
var texture = CreateTexture(layer);
trySave : try
{
var bytes = texture.EncodeToPNG();
System.IO.File.WriteAllBytes(exportPathFolder + "/" + layer.Name + ".png", bytes);
}
catch (Exception e)
{
var retry = DialogHelper.ShowDialog("保存文件出错", e.Message, "重试", "取消");
if (retry)
{
goto trySave;
}
}
}
public static void AnalysisLayerInfo(PsdLayer layer, LayerInfo layerInfo)
{
ResourceDic dic = new ResourceDic();
Rect parentRect = layerInfo.rect;
Rect innerRect = GetSubRectFromLayer(layer, parentRect);
dic.Add("name", layer.Name);
switch (layer.LayerType)
{
case LayerType.Normal:
case LayerType.Color:
layerInfo.sub_images.Add(dic);
dic.Add("sprite", layer.Name + ".png");
dic.Add("rect", ParamAnalysisTool.RectToString(innerRect));
CreatePNGFile(layer);
break;
case LayerType.Text:
layerInfo.sub_texts.Add(dic);
var textInfo = layer.Records.TextInfo;
var color = new Color(textInfo.color[0], textInfo.color[1], textInfo.color[2], textInfo.color[3]);
dic.Add("rect", ParamAnalysisTool.RectToString(GetMarginRect(innerRect, 1.2f)));
dic.Add("color", ParamAnalysisTool.ColorToString(color));
dic.Add("text", textInfo.text);
if (!string.IsNullOrEmpty(textInfo.fontName))
{
dic.Add("font", textInfo.fontName);
}
dic.Add("fontSize", textInfo.fontSize.ToString());
break;
case LayerType.Complex:
Debug.Log("目标层解析能正常，请修改为智能对象！ layer --> " + layer.Name);
layerInfo.sub_images.Add(dic);
dic.Add("sprite", layer.Name + ".png");
dic.Add("rect", ParamAnalysisTool.RectToString(innerRect));
CreatePNGFile(layer);
break;
default:
break;
}
}
/// <summary>
/// 将图层解析为imgNode
/// </summary>
/// <param name="rootSize"></param>
/// <param name="layer"></param>
/// <param name="forceSprite"></param>
/// <returns></returns>
public static Data.ImgNode AnalysisLayer(string baseName, Vector2 rootSize, PsdLayer layer, bool forceSprite = false)
{
Data.ImgNode data = null;
var texture = CreateTexture(layer);
var rect = GetRectFromLayer(layer);
switch (layer.LayerType)
{
case LayerType.Normal:
data = new Data.ImgNode(baseName, rect, texture).SetIndex(CalcuteLayerID(layer)).Analyzing(ExportUtility.RuleObj, layer.Name);
break;
case LayerType.Color:
if (forceSprite)
{
data = new Data.ImgNode(baseName, rect, texture).SetIndex(CalcuteLayerID(layer)).Analyzing(ExportUtility.RuleObj, layer.Name);
}
else
{
data = new Data.ImgNode(layer.Name, rect, GetLayerColor(layer)).SetIndex(CalcuteLayerID(layer));
}
break;
case LayerType.Text:
var textInfo = layer.Records.TextInfo;
var color = new Color(textInfo.color[0], textInfo.color[1], textInfo.color[2], textInfo.color[3]);
data = new Data.ImgNode(layer.Name, rect, textInfo.fontName, textInfo.fontSize, textInfo.text, color);
break;
case LayerType.Complex:
if (!RuleObj.forceSprite)
{
Debug.LogError("you psd have some not supported layer.(defult layer is not supported)! \n make sure your layers is Intelligent object or color lump." + "\n ->Detail:" + layer.Name);
}
data = new Data.ImgNode(baseName, rect, texture).SetIndex(CalcuteLayerID(layer)).Analyzing(ExportUtility.RuleObj, layer.Name);
break;
default:
break;
}
return(data);
}
/// <summary>
/// 将图层解析为imgNode
/// </summary>
/// <param name="rootSize"></param>
/// <param name="layer"></param>
/// <param name="forceSprite"></param>
/// <returns></returns>
public static ImgNode AnalysisLayer(Vector2 rootSize, PsdLayer layer, bool forceSprite = false)
{
ImgNode data = null;
var texture = CreateTexture(layer);
var rect = GetRectFromLayer(layer);
switch (layer.LayerType)
{
case LayerType.Normal:
data = new ImgNode(rect, texture).Analyzing(PsdExportUtility.rouleObj, layer.Name);
break;
case LayerType.SolidImage:
if (forceSprite)
{
data = new ImgNode(rect, texture).Analyzing(PsdExportUtility.rouleObj, layer.Name);
}
else
{
data = new ImgNode(layer.Name, rect, GetLayerColor(layer));
}
break;
case LayerType.Text:
var textInfo = layer.Records.TextInfo;
data = new ImgNode(layer.Name, rect, textInfo.fontName, textInfo.fontSize, textInfo.text, textInfo.color);
break;
case LayerType.Group:
break;
case LayerType.Divider:
break;
default:
break;
}
return(data);
}
/// <summary>
/// 转换为组
/// </summary>
/// <param name="layer"></param>
/// <param name="group"></param>
/// <param name="OnRetrive"></param>
public static void RetriveLayerToSwitchModle(Vector2 rootSize, PsdLayer layer, GroupNodeItem group, bool forceSprite = false)
{
if (!layer.IsGroup)
{
return;
}
else
{
float index = 0;
foreach (var child in layer.Childs)
{
var progress = ++index / layer.Childs.Length;
EditorUtility.DisplayProgressBar(layer.Name, "转换进度:" + progress, progress);
if (child.IsGroup)
{
GroupNodeItem childNode = new GroupNodeItem(GetRectFromLayer(child), idSpan++, group.depth + 1);
childNode.Analyzing(RuleObj, child.Name);
group.AddChild(childNode);
if (childNode != null)
{
RetriveLayerToSwitchModle(rootSize, child, childNode, forceSprite);
}
}
else
{
Data.ImgNode imgnode = AnalysisLayer(group.displayName, rootSize, child, forceSprite);
if (imgnode != null)
{
group.images.Add(imgnode);
}
}
}
EditorUtility.ClearProgressBar();
}
}
/// <summary>
/// 计算平均颜色
/// </summary>
/// <param name="layer"></param>
/// <returns></returns>
public static Color GetLayerColor(PsdLayer layer)
{
Channel red = Array.Find(layer.Channels, i => i.Type == ChannelType.Red);
Channel green = Array.Find(layer.Channels, i => i.Type == ChannelType.Green);
Channel blue = Array.Find(layer.Channels, i => i.Type == ChannelType.Blue);
Channel alpha = Array.Find(layer.Channels, i => i.Type == ChannelType.Alpha);
//Channel mask = Array.Find(layer.Channels, i => i.Type == ChannelType.Mask);
Color[] pixels = new Color[layer.Width * layer.Height];
for (int i = 0; i < pixels.Length; i++)
{
byte r = red.Data[i];
byte g = green.Data[i];
byte b = blue.Data[i];
byte a = 255;
if (alpha != null && alpha.Data[i] != 0)
{
a = (byte)alpha.Data[i];
}
//if (mask != null && mask.Data[i] != 0)
// a *= mask.Data[i];
int mod = i % layer.Width;
int n = ((layer.Width - mod - 1) + i) - mod;
pixels[pixels.Length - n - 1] = new Color(r / 255f, g / 255f, b / 255f, a / 255f);
}
Color color = Color.white;
foreach (var item in pixels)
{
color += item;
color *= 0.5f;
}
return(color);
}
public static string GetLayerPath(PsdLayer layer, NamingConvention fileNaming, GroupMode groupMode)
{
string filename = $"{layer.Name}.png";
string folder = string.Empty;
if (fileNaming != NamingConvention.LayerNameOnly)
{
bool isDir = fileNaming == NamingConvention.CreateGroupFolders;
var docLayer = layer.Document as IPsdLayer;
var parent = layer.Parent;
while (parent != null && parent.Equals(docLayer) == false)
{
if (isDir)
{
if (string.IsNullOrEmpty(folder))
{
folder = parent.Name;
}
else
{
folder = string.Format("{0}/{1}", parent.Name, folder);
}
}
else
{
filename = string.Format("{0}_{1}", parent.Name, filename);
}
parent = parent.Parent;
if (groupMode == GroupMode.ParentOnly)
{
break;
}
}
}
return(filename);
}
private static Texture2D GetTexture(PsdLayer layer)
{
Texture2D texture = new Texture2D(layer.Width, layer.Height);
Color32[] pixels = new Color32[layer.Width * layer.Height];
Channel red = (from l in layer.Channels where l.Type == ChannelType.Red select l).First();
Channel green = (from l in layer.Channels where l.Type == ChannelType.Green select l).First();
Channel blue = (from l in layer.Channels where l.Type == ChannelType.Blue select l).First();
Channel alpha = (from l in layer.Channels where l.Type == ChannelType.Alpha select l).FirstOrDefault();
Channel mask = (from l in layer.Channels where l.Type == ChannelType.Mask select l).FirstOrDefault();
for (int i = 0; i < pixels.Length; i++)
{
byte r = red.Data[i];
byte g = green.Data[i];
byte b = blue.Data[i];
byte a = 255;
if (alpha != null)
{
a = alpha.Data[i];
}
if (mask != null)
{
a *= mask.Data[i];
}
int mod = i % texture.width;
int n = ((texture.width - mod - 1) + i) - mod;
pixels[pixels.Length - n - 1] = new Color32(r, g, b, a);
}
texture.SetPixels32(pixels);
texture.Apply();
return(texture);
}
private static IList <PsdLayerWithScaleFactor> GetPsdLayers(IList <ImportLayerData> layerSettings, PsdDocument psdDoc)
{
var result = new List <PsdLayerWithScaleFactor>();
foreach (var layer in layerSettings)
{
if (layer == null)
{
continue;
}
PsdLayer psdLayer = GetPsdLayerByIndex(psdDoc, layer.indexId);
if (psdLayer.IsGroup)
{
continue;
}
result.Add(new PsdLayerWithScaleFactor()
{
psdLayer = psdLayer, scaleFactor = layer.ScaleFactor
});
}
return(result);
}
public ChannelsBlock(PsdReader reader, long length, PsdLayer layer)
{
Init(reader, length, layer);
}
private static Sprite SaveAsset(PsdLayer psdLayer, TextureImporterSettings psdUnityImport,
Texture2D texture, ImportUserData importSettings, ImportLayerData layerSettings)
{
// Generate the file path for this layer
string fileDir;
string filepath = GetFilePath(psdLayer, importSettings, "png", out fileDir);
// Create the folder if non existent
if (AssetDatabase.IsValidFolder(fileDir) == false)
{
var subPaths = fileDir.Split('/');
string parentFolder = subPaths[0];
foreach (string folder in subPaths.Skip(1))
{
string targetFolder = string.Format("{0}/{1}", parentFolder, folder);
if (AssetDatabase.IsValidFolder(targetFolder) == false)
{
AssetDatabase.CreateFolder(parentFolder, folder);
}
parentFolder = targetFolder;
}
}
// Write out the texture contents into the file
AssetDatabase.CreateAsset(texture, filepath);
byte[] buf = texture.EncodeToPNG();
File.WriteAllBytes(filepath, buf);
AssetDatabase.ImportAsset(filepath, ImportAssetOptions.ForceUpdate);
Texture2D textureObj = AssetDatabase.LoadAssetAtPath <Texture2D>(filepath);
// Get the texture importer for the asset
TextureImporter textureImporter = (TextureImporter)AssetImporter.GetAtPath(filepath);
// Read out the texture import settings so settings can be changed
TextureImporterSettings texSetting = new TextureImporterSettings();
textureImporter.ReadTextureSettings(texSetting);
float finalPPU = psdUnityImport.spritePixelsPerUnit;
switch (layerSettings.ScaleFactor)
{
case ScaleFactor.Half:
finalPPU /= 2;
break;
case ScaleFactor.Quarter:
finalPPU /= 4;
break;
}
// Change settings
texSetting.spriteAlignment = (int)layerSettings.Alignment;
texSetting.spritePivot = layerSettings.Pivot;
texSetting.spritePixelsPerUnit = finalPPU;
texSetting.filterMode = psdUnityImport.filterMode;
texSetting.wrapMode = psdUnityImport.wrapMode;
texSetting.textureType = TextureImporterType.Sprite;
texSetting.spriteMode = (int)SpriteImportMode.Single;
texSetting.mipmapEnabled = false;
texSetting.alphaIsTransparency = true;
texSetting.npotScale = TextureImporterNPOTScale.None;
// Set the rest of the texture settings
textureImporter.spritePackingTag = importSettings.PackingTag;
// Write in the texture import settings
textureImporter.SetTextureSettings(texSetting);
EditorUtility.SetDirty(textureObj);
AssetDatabase.WriteImportSettingsIfDirty(filepath);
AssetDatabase.ImportAsset(filepath, ImportAssetOptions.ForceUpdate);
return((Sprite)AssetDatabase.LoadAssetAtPath(filepath, typeof(Sprite)));
}
