public static void ExtractTextures(List <Texture> textures, PsdLayerExtractor extractor)
{
extractor.Reload();
extractor.SaveLayersToPNGs();
AssetDatabase.Refresh();
foreach (var imageFilePath in extractor.ImageFilePathes)
{
var tex = AssetDatabase.LoadMainAssetAtPath(imageFilePath.filePath) as Texture2D;
if (tex == null)
{
Debug.LogError("Cannot found texture assets. Please check " + imageFilePath.filePath + " file.");
return;
}
var exist = false;
foreach (var t in textures)
{
if (t.name == tex.name)
{
exist = true;
break;
}
}
if (!exist)
{
textures.Add(tex);
}
}
}
public static GameObject CreateGameObject(List <Texture> textures, PsdLayerExtractor extractor)
{
var page_root = new GameObject("page");
page_root.transform.localScale = new Vector3(0.001f, 0.001f, 0.001f);
var layers = extractor.Root.children;
var o_w = extractor.resolution.x;
var o_h = extractor.resolution.y;
//canvasMesh = CanvasMesh();
Debug.Log("H res: " + o_w + " V Res: " + o_h);
for (int i = 0; i < textures.Count; i++)
{
var panel = PanelFromTexture(textures[i]);
panel.transform.parent = page_root.transform;
panel.name = textures[i].name;
var l = extractor.dims[i].x; // - 0.5f * o_w;
var b = -extractor.dims[i].y; // + 0.5f * o_h;
var w = extractor.dims[i].z;
var h = extractor.dims[i].w;
Debug.Log("current panel dims: " + extractor.dims[i]);
//panel.transform.Rotate(panel.transform.forward, 180f);
panel.transform.localPosition = new Vector3(l, b, -i * 100f);
panel.transform.localScale = new Vector3(w, h, 1);
}
return(page_root);
}
public static void ExtractLayers(ref List <PSDLayerData> dataLayers, ref PsdLayerExtractor extractor)
{
//reload the extractor
extractor.Reload();
//initialize the file paths and read the PSD
var psdFilePath = extractor.PsdFilePath;
var prePath = psdFilePath.Substring(0, psdFilePath.Length - 4) + "_layers";
string[] tempData = prePath.Split('/');
var name = extractor.PsdFileName.Split('.')[0];
prePath = "Assets/Images/" + name + "/" + tempData[tempData.Length - 1];
Debug.Log(prePath);
var psdFileStream = new FileStream(extractor.PsdFilePath,
FileMode.Open, FileAccess.Read, FileShare.Read);
//start processing the layers
foreach (var layer in extractor.Root.children)
{
//local extract so that we can recurse if the layer is a container
ExtractLayersLocal(ref dataLayers,
ref extractor,
ref psdFileStream,
layer,
prePath);
}
}
static void OnUpdate()
{
if (!EditorApplication.currentScene.EndsWith("Example.unity"))
return;
var go = GameObject.Find("big");
if (go != null)
return;
EditorApplication.update -= OnUpdate;
var extractor = new PsdLayerExtractor("Assets/PSD2TK2D/Example/big.psd");
{
var filePathes = extractor.saveLayersToPNGs(false);
var textures = new Texture2D[filePathes.Count];
var textureIndex = 0;
var somethingWrong = false;
AssetDatabase.Refresh();
foreach (var filePath in filePathes)
{
var tex = AssetDatabase.LoadMainAssetAtPath(filePath) as Texture2D;
textures[textureIndex++] = tex;
if (somethingWrong = tex == null)
break;
}
if (somethingWrong)
return;
var path = System.IO.Path.GetDirectoryName(extractor.filePath);
var name = extractor.fileName.Substring(0, extractor.fileName.Length - 4);
var collectionName = name + "_SpriteCollection";
PsdLayerTo2DToolKit.makeTK2DSpriteCollection(path, collectionName, textures);
PsdLayerTo2DToolKit.makeTK2DSpriteObjects(name, collectionName, extractor);
}
}
public static void UpdatePanels(bool force = false)
{
int numImagesProcessed = 0;
foreach (var obj in Selection.gameObjects)
{
string updatedText = String.Format("{0}/{1} Pages Complete", numImagesProcessed, Selection.gameObjects.Length);
if (EditorUtility.DisplayCancelableProgressBar("Progress", updatedText, (float)numImagesProcessed / Selection.gameObjects.Length))
{
EditorUtility.ClearProgressBar();
return;
}
//var old_name = obj.name;
//obj.name = "temp";
var page = obj.GetComponent <Page>();
if (page.psdAsset == "" || !File.Exists(page.psdAsset))
{
page.psdAsset = FindPSDFromHint(obj.name);
}
var psd_obj = AssetDatabase.LoadAssetAtPath(page.psdAsset, typeof(UnityEngine.Object));
string filePath = AssetDatabase.GetAssetOrScenePath(psd_obj);
try
{
PsdLayerExtractor extractor = new PsdLayerExtractor(null, psd_obj, filePath, null);
string curr_md5 = extractor.CalcMd5();
if (curr_md5 != page.md5 || force)
{
Debug.Log("Checksum inequality. Updating psd asset: " + extractor.PsdFilePath);
var psd_name = extractor.PsdFileName.Split('.')[0];
var dataLayers = new List <PSDLayerData>();
ExtractLayers(ref dataLayers, ref extractor);
var new_obj = GameObjectFromTextures.CreateUIObject(dataLayers, extractor);
new_obj.name = "temp";
//merge in new sprits, but try to retain other settings
MergeTwoPanels(obj, new_obj);
//update checksum
page.md5 = curr_md5;
}
else
{
Debug.Log("Checksum equality. Skipping psd asset update: " + extractor.PsdFilePath);
}
++numImagesProcessed;
}
catch (Exception E)
{
Debug.Log(E.ToString());
}
}
EditorUtility.ClearProgressBar();
EditorUtility.DisplayDialog("Update Panels", String.Format("{0} Page(s) Complete", numImagesProcessed), "Okay");
}
public static void ExtractLayersLocal(ref List <PSDLayerData> dataLayers,
ref PsdLayerExtractor extractor,
ref FileStream psdFileStream,
PsdLayerExtractor.Layer layer,
string prePath)
{
//exit if we can't parse the layer
if (!layer.canLoadLayer)
{
return;
}
//recurse if the layer is a container
if (layer.isContainer)
{
foreach (var l in layer.children)
{
ExtractLayersLocal(ref dataLayers,
ref extractor,
ref psdFileStream,
l,
prePath);
}
}
else
{
//call the appropriate handler based on layer type
var pa = new PsdLayerCommandParser.ControlParser(prePath, layer);
switch (pa.type)
{
case PsdLayerCommandParser.ControlType.Label:
HandleTextLayer(
ref dataLayers,
ref extractor,
ref psdFileStream,
layer,
prePath,
pa);
break;
case PsdLayerCommandParser.ControlType.Sprite:
HandleImageLayer(
ref dataLayers,
ref extractor,
ref psdFileStream,
layer,
prePath,
pa);
break;
}
}
}
public static void CreatePanelsFromPSD()
{
//try to get a sense of how many pages have already been added
//var pages = GameObject.Find("Pages");
int counter = 0;
//if (pages != null)
// counter = pages.transform.childCount;
var move_vec = new Vector3(1, 0, 0);
//order the selection
var assetNames = new List <string>();
foreach (var id in Selection.assetGUIDs)
{
assetNames.Add(AssetDatabase.GUIDToAssetPath(id));
}
var sorted = assetNames.OrderBy(x => x).ToList();
//loop through the asset selection
foreach (var id in sorted)
{
var psd_obj = AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(id);
PsdLayerExtractor extractor = new PsdLayerExtractor(null, psd_obj, id, null);
var psd_name = extractor.PsdFileName.Split('.')[0];
string updatedText = String.Format("{0}/{1} PSDs Complete: {2}.psd", counter, sorted.Count(), psd_name);
if (EditorUtility.DisplayCancelableProgressBar("Progress", updatedText, (float)counter / sorted.Count()))
{
EditorUtility.ClearProgressBar();
return;
}
var dataLayers = new List <PSDLayerData>();
ExtractLayers(ref dataLayers, ref extractor);
//var textures = new List<Texture>();
//ExtractTextures(textures, extractor);
var new_obj = GameObjectFromTextures.CreateUIObject(dataLayers, extractor);
//now create the layers on the animator
var page_id = new_obj.GetComponent <Page>().uniquePageID;
new_obj.GetComponent <Page>().psdAsset = id;
//move the panel along x-axis for simplified viz
new_obj.transform.position += counter * 10f * move_vec;
counter++;
}
EditorUtility.ClearProgressBar();
}
public static void HandleTextLayer(
ref List <PSDLayerData> dataLayers,
ref PsdLayerExtractor extractor,
ref FileStream psdFileStream,
PsdLayerExtractor.Layer layer,
string prePath,
PsdLayerCommandParser.ControlParser pa)
{
// track the dims and imported asset filepath
var layerData = new PSDLayerData();
layerData.type = 1;
layerData.dimensions = new Vector4(pa.area.left, pa.area.top, pa.area.width, pa.area.height);
layerData.text = layer.text;
layerData.name = layer.name;
//the data to the referenced list
dataLayers.Add(layerData);
}
public static void makeTK2DSpriteObjects(string groupName, string collectionName, PsdLayerExtractor extractor)
{
var screenSize = OrthoCameraSetter.screenSize;
var parent = new GameObject(groupName);
parent.transform.position = new Vector3(0, screenSize.y, 0);
var z = 0f;
var layers = extractor.layers;
foreach (var layer in layers)
{
if (!layer.canLoadLayer)
continue;
var go = makeTK2DSpriteObject(collectionName, layer.name, layer.psdLayer.opacity);
if (go == null)
{
GameObject.DestroyImmediate(parent);
return;
}
// position
var x = (float)layer.psdLayer.area.left;
var y = (float)layer.psdLayer.area.top;
var w = (float)layer.psdLayer.area.width;
go.transform.parent = parent.transform;
{
var pos = new Vector3(x, -y, 0);
pos.z = z;
z -= layerGap;
go.transform.localPosition = pos;
}
// size
var mesh = go.GetComponent<MeshFilter>().sharedMesh;
var bounds = mesh.bounds;
var scale = w / bounds.size.x;
go.transform.localScale = new Vector3(scale, scale, scale);
}
saveCurrentScene();
}
public static void HandleImageLayer(
ref List <PSDLayerData> dataLayers,
ref PsdLayerExtractor extractor,
ref FileStream psdFileStream,
PsdLayerExtractor.Layer layer,
string prePath,
PsdLayerCommandParser.ControlParser pa)
{
var fileName = pa.fullName;
//exit if file name is bad
if (extractor.HasUnacceptibleChar(fileName))
{
Debug.LogError(fileName + " Contains wrong character '\\ / : * ? \" < > |' not allowed");
return;
}
//read the image from the file stream
var filePath = prePath + "/" + fileName + ".png";
PsdLayerExtractor.ImageFilePath newImageFilePath = null;
{
try
{
psdFileStream.Position = 0;
var br = new BinaryReader(psdFileStream);
{
layer.LoadData(br, extractor.Psd.headerInfo.bpp);
newImageFilePath = new PsdLayerExtractor.ImageFilePath(filePath, "pass");
}
}
catch (System.Exception e)
{
Debug.LogError(e.Message);
}
}
//merge channels and check if successful
var data = layer.psdLayer.mergeChannels();
if (data == null)
{
return;
}
//create the texture
Texture tex = null;
if (pa.sliceArea != null)
{
tex = extractor.MakeSlicedSprites(ref data, layer, pa.sliceArea);
}
else
{
tex = extractor.MakeTexture(ref data, layer);
}
if (tex != null)
{
if (!System.IO.Directory.Exists(prePath))
{
System.IO.Directory.CreateDirectory(prePath);
}
//import the texture to the asset database
System.IO.File.WriteAllBytes(filePath, data);
AssetDatabase.Refresh();
TextureImporter importer = AssetImporter.GetAtPath(filePath) as TextureImporter;
ProcessTexture2D(importer, ResolutionOptions.NEXT_SMALLEST, true, false, Platform.iPhone_Android);
// track the dims and imported asset filepath
var layerData = new PSDLayerData();
layerData.type = 0;
layerData.dimensions = new Vector4(pa.area.left, pa.area.top, pa.area.width, pa.area.height);
layerData.texture_path = filePath;
layerData.name = layer.name;
//the data to the referenced list
dataLayers.Add(layerData);
//destroy the temp texture
Texture2D.DestroyImmediate(tex);
}
}
private static void CreateNGUIAtlas(PsdLayerExtractor extractor, List<Texture> textures)
{
var currentPath = PsdLayerToNGUI.CurrentPath;
var name = extractor.PsdFileName.Substring(0, extractor.PsdFileName.Length - 4);
var makeNewAtlas = false;
{
if (PsdLayerToNGUI.data.useOneAtlas)
makeNewAtlas = PsdLayerToNGUI.data.atlasPrefab == null;
else
makeNewAtlas = true;
}
// Font
var isAddFont = false;
if (PsdLayerToNGUI.data.addFont && PsdLayerToNGUI.data.fontType == Data.FontType.Bitmap)
{
if (PsdLayerToNGUI.data.useOneAtlas)
{
isAddFont = PsdLayerToNGUI.data.extractors[0] == extractor; // make only once
}
else
{
isAddFont = extractor.IsAddFont;
}
}
if (isAddFont)
{
NGUIFontCreator.PrepareBitmap(currentPath + name, PsdLayerToNGUI.data);
if (PsdLayerToNGUI.data.fontType == Data.FontType.Bitmap){
textures.Add(PsdLayerToNGUI.data.fontTexture);
}
}
// Atlas
if (makeNewAtlas)
{
var collectionName = name + "_Atlas";
PsdLayerToNGUI.data.atlasPrefab = null;
NGUIAtlasMaker.CreateAtlas(currentPath + collectionName);
PsdLayerToNGUI.data.atlasPrefab = NGUISettings.atlas;
}
else
NGUISettings.atlas = PsdLayerToNGUI.data.atlasPrefab;
NGUIAtlasMaker.UpdateAtlas(textures, PsdLayerToNGUI.data.keepOldSprites);
AssetDatabase.Refresh();
// Font2
if (isAddFont)
{
NGUIFontCreator.CreateBitmap(PsdLayerToNGUI.data);
}
Resources.UnloadUnusedAssets();
}
private static void CreateNGUIs(PsdLayerExtractor extractor)
{
if (!PsdLayerToNGUI.data.createControls || PsdLayerToNGUI.data.atlasPrefab == null){
return;
}
PsdLayerToNGUI.data.nguiDepth = 0;
PsdLayerToNGUI.data.nguiPanelDepth = 0;
NGUISettings.atlas = PsdLayerToNGUI.data.atlasPrefab;
if (PsdLayerToNGUI.data.nguiRoot == null)
{
PsdLayerToNGUI.data.nguiRoot = GameObject.FindObjectOfType(typeof(UIRoot)) as UIRoot;
if (PsdLayerToNGUI.data.nguiRoot != null){
var go = PsdLayerToNGUI.data.nguiRoot.gameObject;
PsdLayerToNGUI.data.nguiRootId = Util.FindComponent<PsdLayerGuid>(go, true).guid;
}
else{
var go = NGUIRootCreator.CreateNewUI().transform.root.gameObject;
PsdLayerToNGUI.data.nguiRoot = go.GetComponent<UIRoot>();
PsdLayerToNGUI.data.nguiRootId = go.AddComponent<PsdLayerGuid>().guid;
}
}
var owner = extractor.Link();
{
var anchor = Util.FindComponent<UIAnchor>(PsdLayerToNGUI.data.nguiRoot);
if (anchor != null)
owner.transform.parent = anchor.transform;
else
owner.transform.parent = PsdLayerToNGUI.data.nguiRoot.transform;
owner.transform.localScale = Vector3.one;
var panel = owner.AddComponent<UIPanel>();
panel.depth = PsdLayerToNGUI.data.nguiPanelDepth++;
}
PsdLayerToNGUI.CreateNGUIs(PsdLayerToNGUI.data.nguiRootGameObject, owner, extractor.PsdFileName, extractor.Root.children);
owner.transform.localPosition = Vector3.zero;
var uicam = Util.FindComponent<UICamera>(PsdLayerToNGUI.data.nguiRoot);
var cam = Util.FindComponent<Camera>(uicam);
Debug.Log ("Camera Mask = " + LayerMask.LayerToName(cam.cullingMask) + "(" + cam.cullingMask + ")");
if (LayerMask.LayerToName(cam.cullingMask) != "Everything")
cam.cullingMask = 1;
}
public void ParseCommandType(string[] name_cmdAndVals,
PsdLayerExtractor.Layer layer, string errorPreMsg)
{
this.command = "";
this.type = ControlType.Sprite;
for (var n=1; n<name_cmdAndVals.Length; ++n)
{
this.command = name_cmdAndVals[n];
if (this.command == "script")
this.type = ControlType.Script;
else if (this.command == "panel")
this.type = ControlType.Panel;
else if (this.command == "scrollview" || this.command.StartsWith("scrollview."))
this.type = ControlType.ScrollView;
else if (this.command == "virtualview" || this.command.StartsWith("virtualview."))
this.type = ControlType.VirtualView;
else if (this.command == "button" || this.command.StartsWith("button.")){
if (layer.isTextLayer && this.command != "button.label")
this.type = ControlType.LabelButton;
else
this.type = ControlType.Button;
}
else if (this.command == "checkbox" || this.command.StartsWith("checkbox.") ||
this.command == "toggle" || this.command.StartsWith("toggle."))
this.type = ControlType.Toggle;
else if (this.command == "combobox" || this.command.StartsWith("combobox."))
this.type = ControlType.ComboBox;
else if (this.command == "input" || this.command.StartsWith("input.") ||
this.command == "editbox" || this.command.StartsWith("editbox."))
this.type = ControlType.Input;
else if (this.command == "password" || this.command.StartsWith("password"))
this.type = ControlType.Password;
else if (this.command == "vscrollbar" || this.command.StartsWith("vscrollbar."))
this.type = ControlType.VScrollBar;
else if (this.command == "hscrollbar" || this.command.StartsWith("hscrollbar."))
this.type = ControlType.HScrollBar;
else if (this.command == "spritefont")
this.type = ControlType.SpriteFont;
else if (this.command == "animation" || this.command == "ani")
this.type = ControlType.SpriteAnimation;
else if (this.command == "texture")
this.type = ControlType.Texture;
if (this.type != ControlType.Sprite)
return; // type setted
}
if (layer.isContainer)
{
this.type = ControlType.Container;
}
else if (layer.isTextLayer)
{
this.type = ControlType.Label;
}
else{
if (!string.IsNullOrEmpty(this.command) &&
!this.command.StartsWith("comment") &&
!this.command.StartsWith("color") &&
!this.command.StartsWith("text") &&
!this.command.StartsWith("bold") &&
!this.command.StartsWith("shadow") &&
!this.command.StartsWith("collider") &&
!this.command.StartsWith("slice") &&
!this.command.StartsWith("align") &&
!this.command.StartsWith("fps") &&
!this.command.StartsWith("ignore"))
{
Debug.LogError(errorPreMsg + "'" + this.command + "'" + " is wrong command or attribute");
}
this.command = "sprite";
this.type = ControlType.Sprite;
}
}
private static List<Texture> ExtractTextures(PsdLayerExtractor extractor)
{
var textures = new List<Texture>();
PsdLayerToNGUI.ExtractTextures(textures, extractor);
return textures;
}
public static GameObject CreateUIObject(List <PSDLayerData> layerData, PsdLayerExtractor extractor)
{
//initialize prefabs
GameObject panel_root_prefab = AssetDatabase.LoadAssetAtPath("Assets/Zyndo/Prefabs/PanelRoot.prefab", typeof(GameObject)) as GameObject;
GameObject panel_layer_prefab = AssetDatabase.LoadAssetAtPath("Assets/Zyndo/Prefabs/PanelLayer.prefab", typeof(GameObject)) as GameObject;
//create the root
GameObject page_root = GameObject.Instantiate(panel_root_prefab);
GameObject container = GameObject.Find("Pages");
page_root.name = extractor.PsdFileName.Split('.')[0];
if (container != null)
{
page_root.transform.SetParent(container.transform);
}
//grab the fade components
//var fadeComps = page_root.GetComponents<PanelFade>();
//attach the canvas group to fade by default
// var cGroup = page_root.GetComponent<CanvasGroup>();
// var fadeIn = new ObjectFadeData(page_root,
// SupportedFadeTypes.CanvasGroup,
// 1.0f, 1.0f);
//
// var fadeOut = new ObjectFadeData(page_root,
// SupportedFadeTypes.CanvasGroup,
// 0.0f, 1.0f);
//
// fadeComps[0].objectsToFade.Add(fadeIn);
// fadeComps[1].objectsToFade.Add(fadeOut);
//proceed with texture import
var o_w = extractor.resolution.x;
var o_h = extractor.resolution.y;
Debug.Log("H res: " + o_w + " V Res: " + o_h);
//initialize the top level rect for mask
var top_rect = page_root.GetComponent <RectTransform>();
var new_top_pos = new Vector3(o_w, o_h, 0.0f);
new_top_pos.x -= 0.5f * o_w;
new_top_pos.y += 05f * o_h;
top_rect.localPosition = new_top_pos;
top_rect.sizeDelta = new Vector2(o_w, o_h);
for (int i = 0; i < layerData.Count; i++)
{
//instantiate a new sub panel
GameObject panel = GameObject.Instantiate(panel_layer_prefab) as GameObject;
panel.transform.SetParent(page_root.transform);
panel.name = layerData[i].name;
//parse the dimensions
var w = layerData[i].dimensions.z;
var h = layerData[i].dimensions.w;
var l = layerData[i].dimensions.x;
var b = -layerData[i].dimensions.y;
//adjust the dimensions for unity
var new_pos = new Vector3(l, b, (layerData.Count - i) * 25f);
new_pos.x -= 0.5f * (o_w - w);
new_pos.y += 0.5f * (o_h - h);
//Debug.Log("current panel dims: " + layerData[i].dimensions);
//adjust the rect transform
var rect_transform = panel.GetComponent <RectTransform>();
rect_transform.localPosition = new_pos;
rect_transform.localScale = Vector3.one;
rect_transform.sizeDelta = new Vector2(w, h);
//setup parallax
var par = panel.GetComponent <Parallax>();
if (par == null)
{
par = panel.AddComponent <Parallax>();
}
if (layerData.Count > 1)
{
par.parallaxFactor = (1.0f / (layerData.Count - 1)) * i;
}
else
{
par.parallaxFactor = 0.1f;
}
//add the specific content
switch (layerData[i].type)
{
case 0:
{
var raw_image = panel.GetComponent <Image>();
//need to load sprite rather than create it
var res = AssetDatabase.FindAssets(panel.name + "@", new string[1] {
"Assets/Images/" + page_root.name
});
if (res.Length < 1)
{
Debug.Log("could not find asset!");
continue;
}
var path = AssetDatabase.GUIDToAssetPath(res[0]);
var sprite = AssetDatabase.LoadAssetAtPath <Sprite>(path);
raw_image.sprite = sprite;
break;
}
case 1:
{
//add speech bubble
var raw_image = panel.GetComponent <Image>();
//raw_image.sprite = AssetDatabase.LoadAssetAtPath<Sprite>("Assets/Zyndo/Textures/SpeechBubble_1.png");
//raw_image.preserveAspect = true;
raw_image.color = 0f * Color.white;
raw_image.enabled = false;
//add canvas group
panel.AddComponent <CanvasGroup>();
panel.AddComponent <DialogueText>();
//add text as child object
var text_obj = new GameObject("Text");
text_obj.transform.parent = panel.transform;
text_obj.transform.localPosition = Vector3.zero;
text_obj.transform.localScale = Vector3.one;
var rect = text_obj.AddComponent <RectTransform>();
rect.sizeDelta = new Vector2(w, h);
text_obj.AddComponent <CanvasRenderer>();
var text = text_obj.AddComponent <TextMeshProUGUI>();
text.enableWordWrapping = true;
text.color = Color.black;
text.fontSize = 0.75f * ((int)layerData[i].dimensions.w);
text.text = layerData[i].text;
break;
}
}
}
//add page component and details
var page = page_root.AddComponent <Page>();
//page.psdAsset = extractor.PsdFileAsset;
page.md5 = extractor.CalcMd5();
//calc unique id
page.uniquePageID = hash6432shift(System.DateTime.Now.Ticks);
//place at origin
page_root.transform.position = Vector3.zero;
return(page_root);
}
private static void AddPsdFileToUpdate(PsdLayerExtractor extractor)
{
lock (PsdLayerToNGUI.updatingExtractor)
{
if (!PsdLayerToNGUI.updatingExtractor.Contains(extractor))
PsdLayerToNGUI.updatingExtractor.Add(extractor);
}
}
private static void UpdateNGUIs(PsdLayerExtractor extractor)
{
if (PsdLayerToNGUI.data.nguiRoot == null || PsdLayerToNGUI.data.atlasPrefab == null){
return;
}
PsdLayerToNGUI.data.nguiDepth = 0;
PsdLayerToNGUI.data.nguiPanelDepth = 0;
NGUISettings.atlas = PsdLayerToNGUI.data.atlasPrefab;
var owner = Util.FindGameObjectRecursively(PsdLayerToNGUI.data.nguiRoot, extractor.PsdFileName);
if (owner == null){
owner = new GameObject(extractor.PsdFileName);
}
PsdLayerToNGUI.UpdateNGUIs(owner, extractor.PsdFileName, extractor.Root.children);
owner.transform.localPosition = Vector3.zero;
}
private static void UpdateNGUIAtlas(PsdLayerExtractor extractor, List<Texture> textures)
{
var currentPath = PsdLayerToNGUI.CurrentPath;
var name = extractor.PsdFileName.Substring(0, extractor.PsdFileName.Length - 4);
var spr = Util.FindComponent<UISprite>(extractor.RootGameObject);
if (spr == null || spr.atlas == null)
{
Debug.LogError("Cannot find atals for " + extractor.PsdFilePath);
return;
}
PsdLayerToNGUI.data.atlasPrefab = spr.atlas;
NGUISettings.atlas = spr.atlas;
var label = Util.FindComponent<UILabel>(extractor.RootGameObject);
if (label != null){
NGUISettings.ambigiousFont = label.ambigiousFont;
}
// Font
var isAddFont = false;
if (PsdLayerToNGUI.data.addFont && PsdLayerToNGUI.data.fontType == Data.FontType.Bitmap)
{
if (PsdLayerToNGUI.data.useOneAtlas)
{
isAddFont = PsdLayerToNGUI.data.extractors[0] == extractor; // make only once
}
else
{
isAddFont = extractor.IsAddFont;
}
}
if (isAddFont)
{
NGUIFontCreator.PrepareBitmap(currentPath + name, PsdLayerToNGUI.data);
if (PsdLayerToNGUI.data.fontType == Data.FontType.Bitmap){
textures.Add(PsdLayerToNGUI.data.fontTexture);
}
}
// Atlas
NGUISettings.atlas = PsdLayerToNGUI.data.atlasPrefab;
NGUIAtlasMaker.UpdateAtlas(textures, PsdLayerToNGUI.data.keepOldSprites);
AssetDatabase.Refresh();
// Font2
if (isAddFont)
{
NGUIFontCreator.CreateBitmap(PsdLayerToNGUI.data);
}
Resources.UnloadUnusedAssets();
}
public ControlParser(string srcFileDirPath, PsdLayerExtractor.Layer layer)
{
var errorPreMsg = "Parse error at '" +srcFileDirPath+ "/" +layer.name+ "'.";
var name_cmdAndVals = layer.name.Split('@');
this.srcFileDirPath = srcFileDirPath;
this.originalName = layer.name;
this.name = name_cmdAndVals[0];
{
for (var i=1; i<name_cmdAndVals.Length; ++i)
{
name_cmdAndVals[i] = name_cmdAndVals[i].Trim().ToLower();
}
}
this.ParseCommandType(name_cmdAndVals, layer, errorPreMsg);
if (this.type == ControlType.Script)
{
this.text = string.IsNullOrEmpty(layer.text) ? "" : layer.text.Trim();
}
else
{
this.fullName = this.name +
(string.IsNullOrEmpty(this.command) ? "" : '@' + this.command);
var comment = this.ParseComment(name_cmdAndVals);
if (!string.IsNullOrEmpty(comment))
this.name = this.name + "(" + comment + ")";
this.area = new PsdLayerRect(
layer.psdLayer.area.left,
layer.psdLayer.area.top,
layer.psdLayer.area.width,
layer.psdLayer.area.height);
this.hasBoxCollider = this.ParseCollider(name_cmdAndVals) == "box";
this.sliceArea = this.ParseSliceArea(name_cmdAndVals);
this.color = this.ParseColor(name_cmdAndVals);
if (!string.IsNullOrEmpty(layer.text))
{
this.text = layer.text.Trim();
var arr = this.text.Split('\n');
this.fontSize = Mathf.FloorToInt(this.area.height / arr.Length * 0.92f);
}
else
this.text = this.ParseText(name_cmdAndVals);
this.bold = this.IsBold(name_cmdAndVals);
this.shadow = this.IsShadow(name_cmdAndVals);
this.align = this.ParseAlign(name_cmdAndVals);
this.fps = this.ParseFps(name_cmdAndVals);
}
}
private static void ExtractTextures(List<Texture> textures, PsdLayerExtractor extractor)
{
extractor.Reload();
extractor.SaveLayersToPNGs();
AssetDatabase.Refresh();
foreach (var imageFilePath in extractor.ImageFilePathes)
{
var tex = AssetDatabase.LoadMainAssetAtPath(imageFilePath.filePath) as Texture2D;
if (tex == null)
{
Debug.LogError("Cannot found texture assets. Please check " + imageFilePath.filePath + " file.");
return;
}
var exist = false;
foreach (var t in textures)
{
if (t.name == tex.name)
{
exist = true;
break;
}
}
if (!exist)
textures.Add(tex);
}
}
