private void OnEnable()
{
Selection.selectionChanged -= HandleSelectionChange;
Selection.selectionChanged += HandleSelectionChange;
stylesLoaded = false;
isAdvancedMode = EditorPrefs.GetBool(PrefKeyAdvancedMode, false);
typeImportUserData = typeof(ImportUserData);
serializer = new fsSerializer();
// Find implementations of IReconstructor
var type = typeof(IReconstructor);
var types = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(s => s.GetTypes())
.Where(p => p != type && type.IsAssignableFrom(p));
List <IReconstructor> constructor_list = new List <IReconstructor>();
List <GUIContent> constructor_dropdown = new List <GUIContent>();
foreach (Type type_constructor in types)
{
var instance = Activator.CreateInstance(type_constructor);
var r_instance = (IReconstructor)instance;
if (r_instance != null)
{
constructor_list.Add(r_instance);
constructor_dropdown.Add(new GUIContent(r_instance.DisplayName));
}
}
reconstructors = constructor_list.ToArray();
dropdownReconstruct = constructor_dropdown.ToArray();
importSettings = new ImportUserData();
}
public static void Reconstruct(Object psdFile, ImportUserData importSettings,
ImportLayerData reconstructRoot, Vector2 documentPivot,
IReconstructor reconstructor)
{
string psdPath = GetPsdFilepath(psdFile);
if (string.IsNullOrEmpty(psdPath))
{
return;
}
using (var psdDoc = PsdDocument.Create(psdPath))
{
ReconstructData data = GetReconstructData(psdDoc, psdPath,
documentPivot, importSettings,
reconstructRoot);
var GO = reconstructor.Reconstruct(reconstructRoot, data, Selection.activeGameObject);
if (GO != null)
{
EditorGUIUtility.PingObject(GO);
Selection.activeGameObject = GO;
}
}
}
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));
}
public static void ImportLayersUI(Object psdFile, ImportUserData importSettings, List <int[]> layerIndices)
{
int total = layerIndices.Count;
Action <int, ImportLayerData> layerCallback = (current, layer) => EditorCoroutineRunner.UpdateUI($"[{current}/{total}] Layer: {layer.name}", (float)current / total);
IEnumerator importCoroutine = ImportCoroutine(psdFile, importSettings.TargetDirectory, importSettings, layerIndices, layerCallback);
EditorCoroutineRunner.StartCoroutineWithUI(importCoroutine, "Importing PSD Layers", true);
}
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);
}
public static void ImportLayersUI(Object psdFile, ImportUserData importSettings, List <int[]> layerIndices)
{
int total = layerIndices.Count;
EditorCoroutineRunner.StartCoroutineWithUI(
ImportCoroutine(psdFile, importSettings, layerIndices, true,
layerCallback: (current, layer) =>
{
string text = string.Format("[{0}/{1}] Layer: {2}", current, total, layer.name);
float percent = (float)current / total;
EditorCoroutineRunner.UpdateUI(text, percent);
}
), "Importing PSD Layers", true
);
}
private static ReconstructData GetReconstructData(PsdDocument psdDoc, string psdPath, Vector2 documentPivot,
ImportUserData importSettings, ImportLayerData reconstructRoot)
{
// Get the texture import setting of the PSD
TextureImporter psdUnitySettings = (TextureImporter)AssetImporter.GetAtPath(psdPath);
TextureImporterSettings psdUnityImport = new TextureImporterSettings();
psdUnitySettings.ReadTextureSettings(psdUnityImport);
Vector2 docSize = new Vector2(psdDoc.Width, psdDoc.Height);
ReconstructData data = new ReconstructData(docSize, documentPivot, psdUnitySettings.spritePixelsPerUnit);
reconstructRoot.Iterate(
layerCallback: layer =>
{
if (layer.import == false)
{
return;
}
var psdLayer = GetPsdLayerByIndex(psdDoc, layer.indexId);
Rect layerBounds = new Rect()
{
xMin = psdLayer.Left,
xMax = psdLayer.Right,
yMin = psdDoc.Height - psdLayer.Bottom,
yMax = psdDoc.Height - psdLayer.Top
};
data.layerBoundsIndex.Add(layer.indexId, layerBounds);
string layerDir;
string layerPath = GetFilePath(psdLayer, importSettings, "png", out layerDir);
string layerMeshDir;
string layerMeshPath = GetFilePath(psdLayer, importSettings, "asset", out layerMeshDir);
Sprite layerSprite = AssetDatabase.LoadAssetAtPath <Sprite>(layerPath);
SpriteMesh layerSpriteMesh = AssetDatabase.LoadAssetAtPath <SpriteMesh>(layerMeshPath);
if (layerSprite == null)
{
layerSprite = ImportLayer(psdDoc, importSettings, layer, psdUnityImport);
}
if (layerSpriteMesh == null && importSettings.GenerateSpriteMesh)
{
layerSpriteMesh = GenerateSpriteMesh(layerSprite);
}
Vector2 spriteAnchor = Vector2.zero;
if (layerSprite != null)
{
TextureImporter layerImporter = (TextureImporter)AssetImporter.GetAtPath(layerPath);
TextureImporterSettings layerSettings = new TextureImporterSettings();
layerImporter.ReadTextureSettings(layerSettings);
if (layerSettings.spriteAlignment == (int)SpriteAlignment.Custom)
{
spriteAnchor = layerSettings.spritePivot;
}
else
{
spriteAnchor = AlignmentToPivot((SpriteAlignment)layerSettings.spriteAlignment);
}
}
data.AddSprite(layer.indexId, layerSprite, spriteAnchor);
if (importSettings.GenerateSpriteMesh)
{
data.AddSpriteMesh(layer.indexId, layerSpriteMesh);
}
},
canEnterGroup: checkGroup => checkGroup.import
);
return(data);
}
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)));
}
private static IEnumerator ImportCoroutine(Object psdFile, ImportUserData importSettings,
List <int[]> layerIndices, bool doYield = false,
Action <int, ImportLayerData> layerCallback = null,
Action <List <Sprite> > completeCallback = null)
{
string filepath = GetPsdFilepath(psdFile);
if (string.IsNullOrEmpty(filepath))
{
if (completeCallback != null)
{
completeCallback(null);
}
yield break;
}
// No target directory set, use PSD file directory
if (string.IsNullOrEmpty(importSettings.TargetDirectory))
{
importSettings.TargetDirectory = filepath.Substring(0, filepath.LastIndexOf("/"));
}
// Get the texture importer for the PSD
TextureImporter psdUnitySettings = (TextureImporter)AssetImporter.GetAtPath(filepath);
TextureImporterSettings psdUnityImport = new TextureImporterSettings();
psdUnitySettings.ReadTextureSettings(psdUnityImport);
int importCurrent = 0;
List <Sprite> sprites = new List <Sprite>();
using (PsdDocument psd = PsdDocument.Create(filepath))
{
foreach (int[] layerIdx in layerIndices)
{
ImportLayerData layerSettings = importSettings.GetLayerData(layerIdx);
if (layerSettings == null)
{
continue;
}
if (layerCallback != null)
{
layerCallback(importCurrent, layerSettings);
}
var sprite = ImportLayer(psd, importSettings, layerSettings, psdUnityImport);
if (importSettings.GenerateSpriteMesh)
{
GenerateSpriteMesh(sprite);
}
sprites.Add(sprite);
importCurrent++;
if (doYield)
{
yield return(null);
}
}
}
if (completeCallback != null)
{
completeCallback(sprites);
}
}
public static void ImportLayers(Object psdFile, ImportUserData importSettings, List <int[]> layerIndices, Action <List <Sprite> > callback = null)
{
EditorCoroutineRunner.StartCoroutine(
ImportCoroutine(psdFile, importSettings, layerIndices, false, completeCallback: callback)
);
}
public static void BuildImportLayerData(Object file, ImportUserData importSettings,
Action <ImportLayerData, DisplayLayerData> callback)
{
string filepath = GetPsdFilepath(file);
if (string.IsNullOrEmpty(filepath))
{
if (callback != null)
{
callback(null, null);
}
return;
}
using (PsdDocument psd = PsdDocument.Create(filepath))
{
ImportLayerData docImportData = new ImportLayerData()
{
name = DOC_ROOT,
indexId = new int[] { -1 },
Childs = new List <ImportLayerData>()
};
DisplayLayerData docDisplayData = new DisplayLayerData()
{
indexId = new int[] { -1 },
Childs = new List <DisplayLayerData>()
};
EditorCoroutineRunner.StartCoroutine(
ParseLayers(psd.Childs, false,
onLayer: (layer, indexId) =>
{
// Walk down the index id to get the parent layers
// and build the full path
string fullPath = "";
ImportLayerData parentLayer = docImportData;
DisplayLayerData parentDisplay = docDisplayData;
if (indexId.Length > 1)
{
for (int idIdx = 0; idIdx < indexId.Length - 1; idIdx++)
{
int idx = indexId[idIdx];
parentLayer = parentLayer.Childs[idx];
parentDisplay = parentDisplay.Childs[idx];
if (string.IsNullOrEmpty(fullPath) == false)
{
fullPath += "/";
}
fullPath += parentLayer.name;
}
}
if (string.IsNullOrEmpty(fullPath) == false)
{
fullPath += "/";
}
fullPath += layer.Name;
ImportLayerData layerImportData = new ImportLayerData()
{
name = layer.Name,
path = fullPath,
indexId = indexId,
import = layer.IsVisible,
useDefaults = true,
Alignment = importSettings.DefaultAlignment,
Pivot = importSettings.DefaultPivot,
ScaleFactor = importSettings.ScaleFactor,
Childs = new List <ImportLayerData>()
};
DisplayLayerData layerDisplayData = new DisplayLayerData()
{
indexId = indexId,
isVisible = layer.IsVisible,
isGroup = layer.Childs.Length > 0,
isOpen = layer.IsFolderOpen
};
int layerIdx = indexId[indexId.Length - 1];
int maxLayers = layerIdx + 1;
while (parentLayer.Childs.Count < maxLayers)
{
parentLayer.Childs.Add(null);
}
parentLayer.Childs[layerIdx] = layerImportData;
while (parentDisplay.Childs.Count < maxLayers)
{
parentDisplay.Childs.Add(null);
}
parentDisplay.Childs[layerIdx] = layerDisplayData;
},
onComplete: () =>
{
if (callback != null)
{
callback(docImportData, docDisplayData);
}
})
);
}
}
public void OpenFile(Object fileObject)
{
if (isOpeningFile)
{
return;
}
importFile = null;
importPath = string.Empty;
importPreview = null;
importPPU = 100;
importSettings = new ImportUserData()
{
DocAlignment = SpriteAlignment.Center
};
importDisplay = null;
selectionCount = 0;
quickSelect.Clear();
lastSelectedLayer = null;
var filePath = AssetDatabase.GetAssetPath(fileObject);
if (filePath.ToLower().EndsWith(".psd") == false)
{
return;
}
importFile = fileObject;
importPath = filePath;
importPreview = AssetDatabase.LoadAssetAtPath <Texture2D>(importPath);
// Read the texture import settings of the asset file
TextureImporter textureImporter = (TextureImporter)AssetImporter.GetAtPath(importPath);
TextureImporterSettings unityImportSettings = new TextureImporterSettings();
textureImporter.ReadTextureSettings(unityImportSettings);
importPPU = unityImportSettings.spritePixelsPerUnit;
// Attempt to deserialize
string json = textureImporter.userData;
bool didGetUserData = false;
if (string.IsNullOrEmpty(json) == false)
{
fsData data = fsJsonParser.Parse(json);
object deserialObj = null;
if (serializer.TryDeserialize(data, typeImportUserData, ref deserialObj)
.AssertSuccessWithoutWarnings()
.Succeeded)
{
importSettings = (ImportUserData)deserialObj;
if (importSettings == null)
{
importSettings = new ImportUserData();
}
else
{
didGetUserData = true;
}
}
}
if (didGetUserData)
{
settingsChanged = false;
}
else
{
settingsChanged = true;
showImportSettings = true;
}
isOpeningFile = true;
PsdImporter.BuildImportLayerData(importFile, importSettings, (layerData, displayData) =>
{
importSettings.DocRoot = ResolveData(importSettings.DocRoot, layerData);
importDisplay = displayData;
isOpeningFile = false;
CollateImportList();
Repaint();
});
}
private static IList <Texture2D> CreateTextures2D(IList <PsdLayerWithScaleFactor> psdLayer, PsdDocument psdDoc, ImportUserData importSettings, TextureImporterSettings psdUnityImport)
{
var result = new List <Texture2D>();
foreach (var layer in psdLayer)
{
// Generate the texture
Texture2D layerTexture = GetLayerTexture(psdDoc, layer.psdLayer, layer.scaleFactor);
if (layerTexture == null)
{
continue;
}
result.Add(layerTexture);
}
return(result);
}
private static IEnumerator ImportCoroutine(Object psdFile, string targetDirectory, ImportUserData importSettings,
List <int[]> layerIndices,
Action <int, ImportLayerData> layerCallback = null,
Action <List <Sprite> > completeCallback = null)
{
string filepath = GetPsdFilepath(psdFile);
if (string.IsNullOrEmpty(filepath))
{
completeCallback?.Invoke(null);
yield break;
}
if (string.IsNullOrEmpty(targetDirectory))
{
targetDirectory = filepath.Substring(0, filepath.LastIndexOf("/"));
}
// Get the texture importer for the PSD
TextureImporter psdUnitySettings = (TextureImporter)AssetImporter.GetAtPath(filepath);
TextureImporterSettings psdUnityImport = new TextureImporterSettings();
psdUnitySettings.ReadTextureSettings(psdUnityImport);
int importCurrent = 0;
var sprites = new List <Sprite>();
using (PsdDocument psd = PsdDocument.Create(filepath)) {
var layersSettings = new List <ImportLayerData>();
foreach (int[] layerIdx in layerIndices)
{
ImportLayerData layerSettings = importSettings.GetLayerData(layerIdx);
if (layerSettings == null)
{
continue;
}
layerCallback?.Invoke(importCurrent, layerSettings);
layersSettings.Add(layerSettings);
}
const float totalSteps = 4.0f;
float currentStep = 0.0f;
EditorCoroutineRunner.UpdateUI($"Getting psd layers", ++currentStep / totalSteps);
yield return(null);
var psdLayers = GetPsdLayers(layersSettings, psd);
EditorCoroutineRunner.UpdateUI($"CreateTextures2D", ++currentStep / totalSteps);
yield return(null);
var textures = CreateTextures2D(psdLayers, psd, importSettings, psdUnityImport);
EditorCoroutineRunner.UpdateUI($"GetTextureWithPathData", ++currentStep / totalSteps);
yield return(null);
var texturesData = GetTextureWithPathData(textures, psdLayers.Select(x => x.psdLayer).ToArray(), importSettings.fileNaming, importSettings.groupMode, targetDirectory);
EditorCoroutineRunner.UpdateUI($"CreateSpriteAssets", ++currentStep / totalSteps);
yield return(null);
sprites.AddRange(CreateSpriteAssets(texturesData, layersSettings, psdUnityImport, importSettings.PackingTag));
}
completeCallback?.Invoke(sprites);
}
