/// <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))); }