/// <summary>
/// Verify that the PSD file will fit into physical memory once loaded
/// and converted to Paint.NET format.
/// </summary>
/// <remarks>
/// This check is necessary because layers in Paint.NET have the same
/// dimensions as the canvas. Thus, PSD files that contain lots of
/// tiny adjustment layers may blow up in size by several
/// orders of magnitude.
/// </remarks>
internal static void CheckSufficientMemory(PsdFile psdFile)
{
// Multichannel images have channels converted to layers
var numLayers = (psdFile.ColorMode == PsdColorMode.Multichannel)
? psdFile.BaseLayer.Channels.Count
: Math.Max(psdFile.Layers.Count, 1);
// Paint.NET also requires a scratch layer and composite layer
numLayers += 2;
long numPixels = (long)psdFile.ColumnCount * psdFile.RowCount;
ulong bytesRequired = (ulong)(checked (4 * numPixels * numLayers));
// Check that the file will fit entirely into physical memory, so that we
// do not thrash and make the Paint.NET UI nonresponsive. We also have
// to check against virtual memory address space because 32-bit processes
// cannot access all 4 GB.
//var computerInfo = new Microsoft.VisualBasic.Devices.ComputerInfo();
//var accessibleMemory = Math.Min(computerInfo.TotalPhysicalMemory,
// computerInfo.TotalVirtualMemory);
var accessibleMemory = (ulong)SystemInfo.systemMemorySize * 1024 * 1024;
if (bytesRequired > accessibleMemory)
{
throw new OutOfMemoryException();
}
}
/// <summary>
/// Set the resolution on the Paint.NET Document to match the PSD file.
/// </summary>
private static void SetPdnResolutionInfo(PsdFile psdFile, Document document)
{
if (psdFile.Resolution != null)
{
// PSD files always specify the resolution in DPI. When loading and
// saving cm, we will have to round-trip the conversion, but doubles
// have plenty of precision to spare vs. PSD's 16/16 fixed-point.
if ((psdFile.Resolution.HResDisplayUnit == ResolutionInfo.ResUnit.PxPerCm) &&
(psdFile.Resolution.VResDisplayUnit == ResolutionInfo.ResUnit.PxPerCm))
{
document.DpuUnit = MeasurementUnit.Centimeter;
// HACK: Paint.NET truncates DpuX and DpuY to three decimal places,
// so add 0.0005 to get a rounded value instead.
document.DpuX = psdFile.Resolution.HDpi / 2.54 + 0.0005;
document.DpuY = psdFile.Resolution.VDpi / 2.54 + 0.0005;
}
else
{
document.DpuUnit = MeasurementUnit.Inch;
document.DpuX = psdFile.Resolution.HDpi;
document.DpuY = psdFile.Resolution.VDpi;
}
}
}
public static ImageC FromStream(Stream stream)
{
long PreviousPosition = stream.Position;
// Read some start bytes
long startPos = stream.Position;
byte[] startBytes = new byte[18];
stream.Read(startBytes, 0, 18);
stream.Position = startPos;
// Detect special image types
if (startBytes[0] == 0x44 && startBytes[1] == 0x44 && startBytes[2] == 0x53 && startBytes[3] == 0x20)
{ // dds image
return(FromPfimImage(Pfim.Dds.Create(stream, new Pfim.PfimConfig())));
}
else if (startBytes[0] == 0x38 && startBytes[1] == 0x42 && startBytes[2] == 0x50 && startBytes[3] == 0x53)
{ // psd image
PsdFile image = new PsdFile();
image.Load(stream);
using (Image image2 = ImageDecoder.DecodeImage(image))
return(FromSystemDrawingImage(image2));
}
else if (IsTga(startBytes))
{ // tga image
return(FromPfimImage(Pfim.Targa.Create(stream, new Pfim.PfimConfig())));
}
else
{ // other image
using (Image image = Image.FromStream(stream))
return(FromSystemDrawingImage(image));
}
}
/// <summary>
/// PSDファイルをトップレベルのレイヤグループ単位で分割します
/// </summary>
/// <param name="outdir_prefix">出力先フォルダのプリフィクス</param>
/// <param name="split_anime_layer">アニメーションレイヤグループ（「@」から始まるレイヤグループ）の展開を許可します</param>
public void Split()
{
//出力先ディレクトリを作成する
string out_dir;
out_dir = Path.Combine(Path.GetDirectoryName(InputFilePath), OutputDirPrefix + Path.GetFileName(InputFilePath));
out_dir = Path.GetFullPath(out_dir);
if (!Directory.Exists(out_dir))
{
Directory.CreateDirectory(out_dir);
}
//PSDを分解する
List <KeyValuePair <string, List <Layer> > > splitted_layers = SplitPsd();
//分解したPSDそれぞれ保存する
for (int i = 0; i < splitted_layers.Count; i++)
{
string name = splitted_layers[i].Key;
List <Layer> layers = splitted_layers[i].Value;
PsdFile psd_out = MakePsd(InputPsdFile, layers);
string out_filename = string.Format("{0}-{1}.psd", Path.GetFileNameWithoutExtension(InputFilePath), name);
Array.ForEach(Path.GetInvalidFileNameChars(), x =>
{
out_filename = out_filename.Replace(x, '_');
});
psd_out.Save(Path.Combine(out_dir, out_filename), Encoding.UTF8);
}
}
private static Channel CreateChannel(ImageCompression compression,
Size size, int bitDepth)
{
var psd = new PsdFile(PsdFileVersion.Psd)
{
BitDepth = bitDepth,
ColorMode = (bitDepth == 1) ? PsdColorMode.Bitmap : PsdColorMode.RGB
};
var layer = new Layer(psd)
{
Rect = new Rectangle(Point.Empty, size)
};
psd.Layers.Add(layer);
var channel = new Channel((short)0, layer)
{
ImageCompression = compression
};
layer.Channels.Add(channel);
return(channel);
}
public static PsdFile MakePsd(PsdFile basefile, IEnumerable <Layer> layers)
{
PsdFile psd = new PsdFile();
psd.ChannelCount = basefile.ChannelCount;
psd.ColorMode = basefile.ColorMode;
psd.BitDepth = basefile.BitDepth;
psd.RowCount = basefile.RowCount;
psd.ColumnCount = basefile.ColumnCount;
psd.ImageCompression = basefile.ImageCompression;
psd.Resolution = basefile.Resolution;
// 画像データのスペースを確保する
int imageSize = psd.RowCount * psd.ColumnCount;
psd.Layers.Clear();
for (short i = 0; i < psd.ChannelCount; i++)
{
var channel = new Channel(i, psd.BaseLayer);
channel.ImageData = new byte[imageSize];
channel.ImageCompression = psd.ImageCompression;
psd.BaseLayer.Channels.Add(channel);
}
psd.Layers.AddRange(layers);
return(psd);
}
private static Bitmap LoadImageFromCache(string sFile)
{
Bitmap zBitmap;
var sKey = sFile.ToLower();
if (!s_dictionaryImages.TryGetValue(sKey, out zBitmap))
{
if (s_dictionaryImages.Count > IMAGE_CACHE_MAX)
{
// TODO: this is a terrible eviction strategy
DumpImagesFromDictionary(s_dictionaryImages);
}
if (!File.Exists(sFile))
{
sFile = ProjectManager.Instance.ProjectPath + sFile;
if (!File.Exists(sFile))
{
return(null);
}
}
Bitmap zSourceImage;
try
{
switch (Path.GetExtension(sFile).ToLower())
{
case ".psd":
{
var zFile = new PsdFile();
zFile.Load(sFile);
zSourceImage = ImageDecoder.DecodeImage(zFile);
}
break;
default:
zSourceImage = new Bitmap(sFile);
break;
}
}
catch (Exception)
{
// return a purple bitmap to indicate an error
zBitmap = new Bitmap(1, 1);
Graphics.FromImage(zBitmap).FillRectangle(Brushes.Purple, 0, 0, zBitmap.Width, zBitmap.Height);
return(zBitmap);
}
zBitmap = new Bitmap(zSourceImage.Width, zSourceImage.Height);
// copy the contents into the image
Graphics zGraphics = Graphics.FromImage(zBitmap);
zGraphics.DrawImage(zSourceImage, new Rectangle(0, 0, zBitmap.Width, zBitmap.Height), 0, 0, zBitmap.Width, zBitmap.Height, GraphicsUnit.Pixel);
// duping the image into a memory copy allows the file to change (not locked by the application)
zSourceImage.Dispose();
CacheImage(s_dictionaryImages, sKey, zBitmap);
}
return(zBitmap);
}
public void LoadInformation(Texture2D Img)
{
string path = AssetDatabase.GetAssetPath(Img);
psd = new PsdFile(path, Encoding.Default);
fileName = Path.GetFileNameWithoutExtension(path);
ApplyLayerSections(psd.Layers);
}
public IList <IPsdLayer> GetLayersAndSize(Stream s, out Size size)
{
PsdFile file = new PsdFile();
file.Load(s);
size = new Size(file.Columns, file.Rows);
return(getLayers(file));
}
public static PsdFile ImportPSD(string path)
{
PsdFile psd = null;
psd = new PsdFile(path, Encoding.Default);
Debug.Log("Import PSD File " + Path.GetFileNameWithoutExtension(path));
return(psd);
}
public static LayerNode ParseLayerTree(PsdFile psd)
{
LayerNode root = new LayerNode();
ParseLayerTree(psd.Layers.GetEnumerator(), root);
return(root);
}
public SaveLayerPixelsContext(BitmapLayer layer, PsdFile psdFile,
Document input, PhotoshopFile.Layer psdLayer, PsdSaveConfigToken psdToken)
{
this.layer = layer;
this.psdFile = psdFile;
this.input = input;
this.psdToken = psdToken;
this.psdLayer = psdLayer;
}
private void ImportLayers()
{
//PSDExporter.CreateSprite(settings, 8);
PsdFile psd = settings.Psd;
Layer layer = psd.Layers[8];
PSDExporter.CreateTexture(layer);
//PSDExporter.Export(settings, fileInfo);
}
private void OnOpenClick(object sender, EventArgs e)
{
string fileName = m_fileName.Text;
if (File.Exists(fileName))
{
UpdateFileLst(fileName);
PsdFile pt = new PsdFile();
this.Cursor = Cursors.WaitCursor;
pt.Load(fileName);
m_fileStructure.Nodes.Clear();
TreeNode fileNode = new TreeNode("PSD File");
fileNode.Tag = pt;
m_fileStructure.Nodes.Add(fileNode);
foreach (Layer layer in pt.Layers)
{
TreeNode layerNode = new TreeNode("Layer Name=" + layer.Name);
layerNode.Tag = layer;
fileNode.Nodes.Add(layerNode);
foreach (Layer.Channel ch in layer.Channels)
{
TreeNode chNode = new TreeNode("Channel ID=" + ch.ID.ToString());
chNode.Tag = ch;
layerNode.Nodes.Add(chNode);
}
TreeNode maskNode = new TreeNode("Mask");
maskNode.Tag = layer.MaskData;
layerNode.Nodes.Add(maskNode);
TreeNode blendingNode = new TreeNode("BlendingRangesData");
blendingNode.Tag = layer.BlendingRangesData;
layerNode.Nodes.Add(blendingNode);
foreach (Layer.AdjustmentLayerInfo adjInfo in layer.AdjustmentInfo)
{
TreeNode node = new TreeNode(adjInfo.Key);
node.Tag = adjInfo;
layerNode.Nodes.Add(node);
}
}
m_fileStructure.SelectedNode = fileNode;
this.Cursor = Cursors.Default;
//pt.Save(Path.Combine(Path.GetDirectoryName(m_fileName.Text), Path.GetFileNameWithoutExtension(m_fileName.Text) + "-s.psd"));
}
}
private IList <IPsdLayer> getLayers(PsdFile file)
{
List <IPsdLayer> items = new List <IPsdLayer>(file.Layers.Count);
for (int i = 0; i < file.Layers.Count; i++)
{
items.Add(new PsdLayer(file.Layers[i], i));
}
return(items);
}
/// <summary>
/// Imports a Photoshop document (.psd) file at the given path.
/// </summary>
/// <param name="asset">The path of to the .psd file relative to the project.</param>
private static void Import(string asset)
{
currentDepth = MaximumDepth;
string fullPath = Path.Combine(GetFullProjectPath(), asset.Replace('\\', '/'));
PsdFile psd = new PsdFile(fullPath);
CanvasSize = new Vector2(psd.Width, psd.Height);
// Set the depth step based on the layer count. If there are no layers, default to 0.1f.
depthStep = psd.Layers.Count != 0 ? MaximumDepth / psd.Layers.Count : 0.1f;
int lastSlash = asset.LastIndexOf('/');
string assetPathWithoutFilename = asset.Remove(lastSlash + 1, asset.Length - (lastSlash + 1));
PsdName = asset.Replace(assetPathWithoutFilename, string.Empty).Replace(".psd", string.Empty);
currentPath = GetFullProjectPath() + "Assets";
currentPath = Path.Combine(currentPath, PsdName);
Directory.CreateDirectory(currentPath);
if (LayoutInScene || CreatePrefab)
{
if (UseUnityUI)
{
CreateUIEventSystem();
CreateUICanvas();
rootPsdGameObject = Canvas;
}
else
{
rootPsdGameObject = new GameObject(PsdName);
}
currentGroupGameObject = rootPsdGameObject;
}
List <Layer> tree = BuildLayerTree(psd.Layers);
ExportTree(tree);
if (CreatePrefab)
{
UnityEngine.Object prefab = PrefabUtility.CreateEmptyPrefab(asset.Replace(".psd", ".prefab"));
PrefabUtility.ReplacePrefab(rootPsdGameObject, prefab);
if (!LayoutInScene)
{
// if we are not flagged to layout in the scene, delete the GameObject used to generate the prefab
UnityEngine.Object.DestroyImmediate(rootPsdGameObject);
}
}
AssetDatabase.Refresh();
}
/// <summary>
/// Reset everything back to default
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void NewMenu_Click(object sender, RoutedEventArgs e)
{
// Clear our ListView, Canvas, Images
HudItemList.Items.Clear();
HudCanvas.Children.Clear();
// Set all back to null
psdFile = null;
selectedHudElem = null;
selectedPreviewImage = null;
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="filepath">入力PSDファイルパス</param>
/// <param name="nonUnicodeEncoding">非ユニコードのレイヤ名のエンコーディング</param>
public PsdSplitter(string filepath, Encoding nonUnicodeEncoding)
{
InputFilePath = Path.GetFullPath(filepath);
InputPsdFile = new PsdFile();
OutputDirPrefix = "out-";
using (var fs = new FileStream(filepath, FileMode.Open, FileAccess.Read))
{
InputPsdFile.Load(fs, nonUnicodeEncoding);
}
}
public static void Generator(PsdFile psd, UIAtlas uiAtlas, string rootName)
{
Debug.Log("Generate Start!");
Debug.Log(psd.BaseLayer.Rect.width + " " + psd.BaseLayer.Rect.height);
GameObject root = null;
if (rootName == null || (root = GameObject.Find(rootName)) == null)
{
Debug.LogError("Root not found!");
return;
}
foreach (Layer layer in psd.Layers)
{
if (layer.Name != "</Layer set>" &&
layer.Name != "</Layer group>" &&
layer.Visible &&
layer.Rect.width > 0 &&
layer.Rect.height > 0)
{
Debug.Log(layer.Name);
Debug.Log(layer.Rect.width + " " + layer.Rect.height);
string pattern = "label_";
Regex regexInstance = new Regex(pattern);
if (regexInstance.IsMatch(layer.Name))
{
UILabel label = NGUITools.AddWidget <UILabel>(root, 1);
label.pivot = UIWidget.Pivot.TopLeft;
Vector3 spritePos = new Vector3(layer.Rect.position.x - psd.BaseLayer.Rect.width / 2, psd.BaseLayer.Rect.height / 2 - layer.Rect.position.y);
Debug.Log("before: " + layer.Rect.position + " after: " + spritePos);
label.name = layer.Name;
label.width = (int)layer.Rect.width;
label.height = (int)layer.Rect.height;
label.transform.localPosition = spritePos;
label.pivot = UIWidget.Pivot.Center;
}
else
{
UISprite sprite = NGUITools.AddSprite(root, uiAtlas, layer.Name, 1);
sprite.pivot = UIWidget.Pivot.TopLeft;
Vector3 spritePos = new Vector3(layer.Rect.position.x - psd.BaseLayer.Rect.width / 2, psd.BaseLayer.Rect.height / 2 - layer.Rect.position.y);
Debug.Log("before: " + layer.Rect.position + " after: " + spritePos);
sprite.name = layer.Name;
sprite.width = (int)layer.Rect.width;
sprite.height = (int)layer.Rect.height;
sprite.transform.localPosition = spritePos;
sprite.pivot = UIWidget.Pivot.Center;
sprite.type = UISprite.Type.Sliced;
}
}
}
}
private void executeButton_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(folderPath) || string.IsNullOrEmpty(filePath))
{
MessageBox.Show("ファイルまたはフォルダが選択されていません");
return;
}
PsdFile psd = new PsdFile();
psd.Load(filePath);
List <string> layerName = new List <string>();
foreach (var layer in psd.Layers)
{
layerName.Add(layer.Name);
}
using (MagickImageCollection imgs = new MagickImageCollection(filePath))
{
for (int i = 0; i < imgs.Count; i++)
{
imgs[i].GifDisposeMethod = GifDisposeMethod.Background;
}
imgs.Coalesce();
for (int i = 0; i < imgs.Count; i++)
{
imgs[i].GifDisposeMethod = GifDisposeMethod.Background;
string saveFileName;
try
{
saveFileName = Path.Combine(folderPath, layerName[i] + ".png");
}
catch
{
saveFileName = "error_name";
}
imgs[i].Write(saveFileName);
}
imgs.RemoveAt(0);
}
//Application.Exit();
}
///////////////////////////////////////////////////////////////////////////
unsafe private static void SetPDNColor(ColorBgra* dstPixel, PsdFile psdFile, int pos)
{
switch (psdFile.ColorMode)
{
case PsdFile.ColorModes.RGB:
dstPixel->R = psdFile.ImageData[0][pos];
dstPixel->G = psdFile.ImageData[1][pos];
dstPixel->B = psdFile.ImageData[2][pos];
break;
case PsdFile.ColorModes.CMYK:
SetPDNColorCMYK(dstPixel,
psdFile.ImageData[0][pos],
psdFile.ImageData[1][pos],
psdFile.ImageData[2][pos],
psdFile.ImageData[3][pos]);
break;
case PsdFile.ColorModes.Multichannel:
SetPDNColorCMYK(dstPixel,
psdFile.ImageData[0][pos],
psdFile.ImageData[1][pos],
psdFile.ImageData[2][pos],
0);
break;
case PsdFile.ColorModes.Bitmap:
byte bwValue = ImageDecoder.GetBitmapValue(psdFile.ImageData[0], pos);
dstPixel->R = bwValue;
dstPixel->G = bwValue;
dstPixel->B = bwValue;
break;
case PsdFile.ColorModes.Grayscale:
case PsdFile.ColorModes.Duotone:
dstPixel->R = psdFile.ImageData[0][pos];
dstPixel->G = psdFile.ImageData[0][pos];
dstPixel->B = psdFile.ImageData[0][pos];
break;
case PsdFile.ColorModes.Indexed:
int index = (int)psdFile.ImageData[0][pos];
dstPixel->R = (byte)psdFile.ColorModeData[index];
dstPixel->G = psdFile.ColorModeData[index + 256];
dstPixel->B = psdFile.ColorModeData[index + 2 * 256];
break;
case PsdFile.ColorModes.Lab:
SetPDNColorLab(dstPixel,
psdFile.ImageData[0][pos],
psdFile.ImageData[1][pos],
psdFile.ImageData[2][pos]);
break;
}
}
/// <summary>
/// Modify Sprite atlass meta by Psd Layer
/// </summary>
public static void CreatSpriteFromLayers(PsdFile psd, AssetImporter importer)
{
TextureImporter texImp = importer as TextureImporter;
string name = Path.GetFileNameWithoutExtension(importer.assetPath);
name = name.Replace("_" + psdImportSettings.psdSuffix, "");
SpriteMetaData[] tmpMeta = texImp.spritesheet;
List <SpriteMetaData> sprMeta = new List <SpriteMetaData>();
texImp.textureType = TextureImporterType.Sprite;
texImp.spriteImportMode = SpriteImportMode.Multiple;
//texImp.spritePixelsPerUnit = 100;
//texImp.spritePackingTag = null;
//texImp.anisoLevel = 1;
//texImp.wrapMode = TextureWrapMode.Repeat;
//texImp.filterMode = FilterMode.Bilinear;
foreach (Layer layer in psd.Layers)
{
if (layer.Name != "</Layer set>" &&
layer.Name != "</Layer group>" &&
layer.Visible &&
layer.Rect.width > 0 &&
layer.Rect.height > 0)
{
SpriteMetaData smd = new SpriteMetaData();
smd.name = name + "." + layer.Name;
smd.rect = new Rect(
layer.Rect.x,
psd.RowCount - layer.Rect.y - layer.Rect.height,
layer.Rect.width,
layer.Rect.height);
foreach (SpriteMetaData s in tmpMeta)
{
if (smd.name == s.name)
{
smd.pivot = s.pivot;
smd.border = s.border;
smd.alignment = s.alignment;
}
}
sprMeta.Add(smd);
}
}
texImp.spritesheet = sprMeta.ToArray();
}
void OnPostprocessTexture(Texture2D text)
{
///Load PSD
if (assetPath.ToLower().EndsWith(PSDUtils.psdImportSettings.psdSuffix + ".psd"))
{
PsdFile psd = PSDUtils.ImportPSD(assetPath);
if (psd != null)
{
PSDUtils.CreatSpriteFromLayers(psd, assetImporter);
}
else
{
LogError("Can not read the PSD Atlass File: " + assetPath);
}
}
}
public PsdExportSettings(string path)
{
if (!path.ToUpper().EndsWith(".PSD"))
{
return;
}
FullFileName = path;
ExportPath = PsdSetting.Instance.DefaultImportPath;
Psd = new PsdFile(path, Encoding.Default);
Filename = Path.GetFileNameWithoutExtension(path);
ScaleBy = 0;
Pivot = SpriteAlignment.Center;
PixelsToUnitSize = 100f;
}
public PsdExportSettings(Texture2D image)
{
string path = AssetDatabase.GetAssetPath(image);
if (!path.ToUpper().EndsWith(".PSD"))
{
return;
}
Psd = new PsdFile(path, Encoding.Default);
Filename = Path.GetFileNameWithoutExtension(path);
Image = image;
ScaleBy = 0;
Pivot = SpriteAlignment.Center;
PixelsToUnitSize = 100f;
LoadMetaData();
}
public InfoLayers(PsdFile psdFile, string key)
{
PsdFile = psdFile;
switch (key)
{
// The key does not have to match the bit depth, but it does have to
// be one of the known values.
case "Layr":
case "Lr16":
case "Lr32":
this.key = key;
break;
default:
throw new PsdInvalidException(
$"{nameof(InfoLayers)} key must be Layr, Lr16, or Lr32.");
}
}
protected override Document OnLoad(System.IO.Stream input)
{
PsdFile psdFile = new PsdFile();
psdFile.Load(input);
Document document = new Document(psdFile.Columns, psdFile.Rows);
if (psdFile.Resolution != null)
{
document.DpuUnit = MeasurementUnit.Inch;
document.DpuX = psdFile.Resolution.HRes;
document.DpuY = psdFile.Resolution.VRes;
}
if (psdFile.Layers.Count == 0)
{
BitmapLayer layer = ImageDecoderPdn.DecodeImage(psdFile);
document.Layers.Add(layer);
}
else
{
PaintDotNet.Threading.PrivateThreadPool threadPool = new PaintDotNet.Threading.PrivateThreadPool();
var layersList = new List <Layer>();
foreach (PhotoshopFile.Layer l in psdFile.Layers)
{
if (!l.Rect.IsEmpty)
{
layersList.Add(null);
LoadLayerContext llc = new LoadLayerContext(l, document, BlendModeKeyToBlendOp(l), layersList, layersList.Count - 1);
WaitCallback waitCallback = new WaitCallback(llc.LoadLayer);
threadPool.QueueUserWorkItem(waitCallback);
}
}
threadPool.Drain();
foreach (var layer in layersList)
{
document.Layers.Add(layer);
}
}
return(document);
}
private static List <PanelNode> GetLayer(Texture2D psdFile, string filter = "")
{
List <PanelNode> PanelNodeList = new List <PanelNode> ();
PsdExportSettings settings = new PsdExportSettings(psdFile);
PsdFileInfo fileInfo = new PsdFileInfo(settings.Psd);
bool valid = (settings.Psd != null);
if (valid)
{
settings.LoadLayers(fileInfo);
PsdFile psd = settings.Psd;
int layerIndexMin = 0;
int layerIndexMax = 0;
for (int i = 0; i < psd.Layers.Count; i++)
{
PSDLayerGroupInfo groupInfo = fileInfo.GetGroupByLayerIndex(i);
//Debug.Log (groupInfo.start + "-" + groupInfo.end + ":" + groupInfo.name);
if (groupInfo != null && !PanelNodeList.Exists(a => a.Name.Equals(groupInfo.name)))
{
PanelNode panelNode = new PanelNode(groupInfo.name);
panelNode.visible = groupInfo.visible;
panelNode.idxStart = groupInfo.start;
panelNode.idxEnd = groupInfo.end;
panelNode.isGroup = true;
PanelNodeList.Add(panelNode);
}
}
for (int i = 0; i < fileInfo.LayerIndices.Length; i++)
{
int layerIndex = fileInfo.LayerIndices [i];
Layer layer = psd.Layers [layerIndex];
PanelNode panelNode = new PanelNode(layer.Name);
panelNode.visible = layer.Visible;
panelNode.Index = layerIndex;
panelNode.isGroup = false;
panelNode.layer = layer;
PanelNodeList.Add(panelNode);
}
ArrangementNode(PanelNodeList);
}
return(PanelNodeList);
}
private void OnGUI()
{
EditorGUI.BeginChangeCheck();
originTexture = (Texture2D)EditorGUILayout.ObjectField("psd", originTexture, typeof(Texture2D), false);
if (originTexture == null)
{
originPsd = null;
return;
}
if (EditorGUI.EndChangeCheck() || (originTexture != null && originPsd == null))
{
UpdateOriginTexture();
}
fontData = (Font)EditorGUILayout.ObjectField("font", fontData, typeof(Font), false);
EditorGUILayout.Space();
if (saveEditor != null)
{
saveEditor.Draw(position.position);
}
if (GUILayout.Button("Convert"))
{
GameObject canvasObj = GameObject.Find("Canvas");
if (canvasObj == null)
{
canvasObj = new GameObject("Canvas");
var canvas = canvasObj.AddComponent <Canvas>();
canvas.renderMode = RenderMode.ScreenSpaceOverlay;
var scalor = canvasObj.AddComponent <CanvasScaler>();
scalor.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
scalor.referenceResolution = originSize;
}
Convert();
UpdateOriginTexture();
}
}
public SaveAssetEditor(PsdFile psd, string assetSavePath)
{
this.assetSavePath = assetSavePath;
foreach (var layer in psd.Layers)
{
if (layer.AdditionalInfo.Any(x => x is LayerSectionInfo))
{
continue;
}
if (layer.AdditionalInfo.Any(x => x is TextLayerInfo))
{
continue;
}
if (layer.Rect.width <= 0 || layer.Rect.height <= 0)
{
continue;
}
if (layers.Any(x => x.layer.Name == layer.Name))
{
continue;
}
var origin = EditorUtil.CreateTexture(layer);
if (origin == null)
{
continue;
}
var sprite = AssetDatabase.LoadAssetAtPath <Sprite>(EditorUtil.GetAssetPath(assetSavePath, layer.Name));
layers.Add(new TempLayer
{
layer = layer,
originTexture = origin,
existTexture = sprite,
overWrite = sprite == null,
});
}
layers = layers.OrderBy(x => x.layer.Name).ToList();
}
