763 lines
25 KiB
C#
763 lines
25 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEditor;
|
|
using Coolape;
|
|
using System;
|
|
using System.IO;
|
|
|
|
public class ECLSpritePacker : EditorWindow
|
|
{
|
|
public enum PackerSize
|
|
{
|
|
max_Sprite_Count_50 = 50,
|
|
max_Sprite_Count_100 = 100,
|
|
max_Sprite_Count_150 = 150,
|
|
max_Sprite_Count_200 = 200,
|
|
}
|
|
|
|
public enum PackerTextureSize
|
|
{
|
|
Texture_Size_512 = 512,
|
|
Texture_Size_1024 = 1024,
|
|
Texture_Size_2048 = 2048,
|
|
Texture_Size_4096 = 4096,
|
|
}
|
|
|
|
public enum SortSprite
|
|
{
|
|
none,
|
|
SortArea,
|
|
SortLength,
|
|
}
|
|
|
|
static string mSpritesBorrowInforFile = "";
|
|
static int cellSize = 70;
|
|
static Rect rect = new Rect (50f, 0, cellSize, cellSize);
|
|
static ArrayList mSpriteList = new ArrayList ();
|
|
PackerSize packerSize = PackerSize.max_Sprite_Count_100;
|
|
PackerTextureSize textureSize = PackerTextureSize.Texture_Size_1024;
|
|
SortSprite sortSprite = SortSprite.SortArea;
|
|
Vector2 scrollPos = Vector2.zero;
|
|
Vector2 scrollPos2 = Vector2.zero;
|
|
static string mSelectedSprite = "";
|
|
Hashtable item;
|
|
bool isSelectedAll = false;
|
|
int selectedCount = 0;
|
|
int allSpriteCount = 0;
|
|
Hashtable currSelectSprite;
|
|
bool isShowParckerView = false;
|
|
bool isShowParckerTextureBg = false;
|
|
Texture2D packTex;
|
|
static Rect[] packRects;
|
|
static List<Hashtable> packSprites = new List<Hashtable> ();
|
|
static string packedName = "";
|
|
Texture2D _empty;
|
|
bool isUseUnityPacking = true;
|
|
bool showDeltail = false;
|
|
bool removePublishRes = true;
|
|
|
|
void OnGUI ()
|
|
{
|
|
GUILayout.Space (5);
|
|
ECLEditorUtl.BeginContents ();
|
|
{
|
|
EditorGUILayout.BeginHorizontal ();
|
|
{
|
|
if (GUILayout.Button ("Sprites Borrow Infor File", ECLEditorUtl.width150)) {
|
|
string _mSpritesBorrowInforFile = EditorUtility.OpenFilePanel ("Select Infor File", Application.dataPath + "/KOK/xRes/spriteBorrow", "json");
|
|
if (!mSpritesBorrowInforFile.Equals (_mSpritesBorrowInforFile)) {
|
|
mSpritesBorrowInforFile = _mSpritesBorrowInforFile;
|
|
initData ();
|
|
}
|
|
}
|
|
if (GUILayout.Button ("Refresh", ECLEditorUtl.width80)) {
|
|
initData ();
|
|
}
|
|
GUILayout.TextField (mSpritesBorrowInforFile);
|
|
}
|
|
EditorGUILayout.EndHorizontal ();
|
|
GUILayout.Space (5);
|
|
EditorGUILayout.BeginHorizontal ();
|
|
{
|
|
packerSize = (PackerSize)EditorGUILayout.EnumPopup ("", packerSize);
|
|
GUI.color = Color.yellow;
|
|
if (GUILayout.Button ("Packer View")) {
|
|
isShowParckerView = true;
|
|
currSelectSprite = null;
|
|
}
|
|
GUI.color = Color.white;
|
|
}
|
|
EditorGUILayout.EndHorizontal ();
|
|
}
|
|
ECLEditorUtl.EndContents ();
|
|
GUILayout.Space (5);
|
|
|
|
EditorGUILayout.BeginHorizontal ();
|
|
{
|
|
EditorGUILayout.BeginVertical ();
|
|
{
|
|
bool _isSelectedAll = EditorGUILayout.ToggleLeft ("All", isSelectedAll, ECLEditorUtl.width150);
|
|
if (isSelectedAll != _isSelectedAll) {
|
|
isSelectedAll = _isSelectedAll;
|
|
for (int i = 0; i < mSpriteList.Count && i < (int)packerSize; i++) {
|
|
item = mSpriteList [i] as Hashtable;
|
|
item ["selected"] = isSelectedAll;
|
|
}
|
|
refreshSelectedCount ();
|
|
}
|
|
scrollPos = EditorGUILayout.BeginScrollView (scrollPos, ECLEditorUtl.width150);
|
|
{
|
|
rect.y = 0;
|
|
ECLEditorUtl.BeginContents ();
|
|
{
|
|
// GUILayout.Space (10);
|
|
for (int i = 0; i < mSpriteList.Count && i < (int)packerSize; i++) {
|
|
item = mSpriteList [i] as Hashtable;
|
|
bool selected = GUI.Toggle (new Rect (5, rect.y, 50, cellSize + 30), MapEx.getBool (item, "selected"), (i + 1).ToString ());
|
|
if (selected != MapEx.getBool (item, "selected")) {
|
|
item ["selected"] = selected;
|
|
refreshSelectedCount ();
|
|
}
|
|
showCellSprite (item);
|
|
}
|
|
}
|
|
ECLEditorUtl.EndContents ();
|
|
}
|
|
EditorGUILayout.EndScrollView ();
|
|
}
|
|
EditorGUILayout.EndVertical ();
|
|
//=========================================
|
|
//=========================================
|
|
EditorGUILayout.BeginVertical ();
|
|
{
|
|
GUILayout.Label (PStr.b ().a ("Selected: ").a (selectedCount).a ("/").a (allSpriteCount).e ());
|
|
scrollPos2 = EditorGUILayout.BeginScrollView (scrollPos2, GUILayout.Width (position.width - 150));
|
|
{
|
|
ECLEditorUtl.BeginContents ();
|
|
{
|
|
if (isShowParckerView) {
|
|
showPackerView ();
|
|
} else {
|
|
showSpriteInfor ();
|
|
}
|
|
}
|
|
ECLEditorUtl.EndContents ();
|
|
}
|
|
EditorGUILayout.EndScrollView ();
|
|
}
|
|
EditorGUILayout.EndVertical ();
|
|
}
|
|
EditorGUILayout.EndHorizontal ();
|
|
}
|
|
|
|
void refreshSelectedCount ()
|
|
{
|
|
int ret = 0;
|
|
allSpriteCount = 0;
|
|
selectedCount = 0;
|
|
for (int i = 0; i < mSpriteList.Count && i < (int)packerSize; i++) {
|
|
allSpriteCount += 1;
|
|
item = mSpriteList [i] as Hashtable;
|
|
if (MapEx.getBool (item, "selected")) {
|
|
ret += 1;
|
|
}
|
|
}
|
|
selectedCount = ret;
|
|
}
|
|
|
|
void showPackerView ()
|
|
{
|
|
if (packTex != null) {
|
|
//=================
|
|
float h = 0;
|
|
float w = position.width - 160;
|
|
float rate = w / packTex.width;
|
|
if (rate < 1) {
|
|
h = packTex.height * rate;
|
|
} else {
|
|
h = packTex.height;
|
|
}
|
|
h = h > 512 ? h : 512;
|
|
Rect r = new Rect (0, 0, NumEx.getIntPart (w), NumEx.getIntPart (h));
|
|
NGUIEditorTools.DrawTiledTexture (r, NGUIEditorTools.backdropTexture);
|
|
if (isShowParckerTextureBg) {
|
|
GUI.DrawTexture (r, _empty, ScaleMode.ScaleToFit, false);
|
|
}
|
|
GUI.DrawTexture (r, packTex, ScaleMode.ScaleToFit);
|
|
GUILayout.Space (r.height + r.y); //这句主要目的是为了可以滑动
|
|
|
|
ECLEditorUtl.BeginContents ();
|
|
{
|
|
EditorGUILayout.BeginHorizontal ();
|
|
{
|
|
EditorGUILayout.IntField ("width", packTex.width);
|
|
EditorGUILayout.IntField ("height", packTex.height);
|
|
}
|
|
EditorGUILayout.EndHorizontal ();
|
|
if (GUILayout.Button ("Show/Hide Detail")) {
|
|
showDeltail = !showDeltail;
|
|
}
|
|
if (showDeltail) {
|
|
if (packSprites != null) {
|
|
Hashtable m = null;
|
|
Hashtable d = null;
|
|
Rect _rect;
|
|
for (int i = 0; i < packSprites.Count; i++) {
|
|
_rect = packRects [i];
|
|
m = packSprites [i] as Hashtable;
|
|
d = MapEx.getMap (m, "data");
|
|
EditorGUILayout.BeginHorizontal ();
|
|
{
|
|
EditorGUILayout.LabelField (MapEx.getString (d, "name"));
|
|
EditorGUILayout.LabelField (Mathf.RoundToInt (_rect.x) + "x" + Mathf.RoundToInt (_rect.y));
|
|
EditorGUILayout.LabelField (Mathf.RoundToInt (_rect.width) + "x" + Mathf.RoundToInt (_rect.height));
|
|
}
|
|
EditorGUILayout.EndHorizontal ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ECLEditorUtl.EndContents ();
|
|
|
|
}
|
|
|
|
isShowParckerTextureBg = EditorGUILayout.ToggleLeft ("Show Background", isShowParckerTextureBg);
|
|
textureSize = (PackerTextureSize)EditorGUILayout.EnumPopup ("", textureSize);
|
|
isUseUnityPacking = EditorGUILayout.ToggleLeft ("UnityPacking", isUseUnityPacking);
|
|
sortSprite = (SortSprite)EditorGUILayout.EnumPopup ("", sortSprite);
|
|
GUILayout.Space (5);
|
|
GUI.color = Color.yellow;
|
|
if (GUILayout.Button ("Review Pack Texture")) {
|
|
if (!packTextures ((int)textureSize, isUseUnityPacking)) {
|
|
Debug.LogError ("Some errors happened!");
|
|
}
|
|
}
|
|
GUI.color = Color.white;
|
|
GUILayout.Space (10);
|
|
|
|
ECLEditorUtl.BeginContents ();
|
|
{
|
|
packedName = EditorGUILayout.TextField ("Packed Texture Name", string.IsNullOrEmpty (packedName) ? "Packed" + (int)packerSize : packedName);
|
|
GUI.color = Color.red;
|
|
removePublishRes = EditorGUILayout.ToggleLeft ("Remove Publish AssetsBundle", removePublishRes);
|
|
if (GUILayout.Button ("Apply Pack Texture")) {
|
|
applyPackTexture ((int)textureSize, isUseUnityPacking);
|
|
}
|
|
GUI.color = Color.white;
|
|
}
|
|
ECLEditorUtl.EndContents ();
|
|
}
|
|
|
|
|
|
void applyPackTexture (int maxSize, bool unityPacking)
|
|
{
|
|
string texturePath = EditorUtility.OpenFolderPanel ("Save packed texture", Application.dataPath + "/" + CLPathCfg.self.basePath + "/upgradeRes4Dev/other", "");
|
|
if (string.IsNullOrEmpty (texturePath)) {
|
|
return;
|
|
}
|
|
if (packTex == null || packRects == null || packRects.Length == 0 || packSprites == null || packSprites.Count == 0 || packRects.Length != packSprites.Count) {
|
|
packTextures (maxSize, isUseUnityPacking);
|
|
}
|
|
string packTextureFile = Path.Combine (texturePath, packedName + ".png");
|
|
string packTextureFile4Atlas = packTextureFile.Replace (Application.dataPath + "/", "");
|
|
Debug.LogWarning (packTextureFile4Atlas);
|
|
|
|
byte[] bytes = packTex.EncodeToPNG ();
|
|
Directory.CreateDirectory (Path.GetDirectoryName (packTextureFile));
|
|
File.WriteAllBytes (packTextureFile, bytes);
|
|
AssetDatabase.ImportAsset ("Assets/" + packTextureFile4Atlas);
|
|
TextureImporter textureImporter = AssetImporter.GetAtPath ("Assets/" + packTextureFile4Atlas) as TextureImporter;
|
|
textureImporter.textureType = TextureImporterType.GUI;
|
|
textureImporter.mipmapEnabled = false;
|
|
textureImporter.wrapMode = TextureWrapMode.Clamp;
|
|
textureImporter.alphaIsTransparency = true;
|
|
textureImporter.npotScale = TextureImporterNPOTScale.None;
|
|
textureImporter.filterMode = FilterMode.Trilinear; //改成这种模式好像更省内存
|
|
AssetDatabase.ImportAsset ("Assets/" + packTextureFile4Atlas);
|
|
|
|
Hashtable m = null;
|
|
Hashtable d = null;
|
|
Hashtable atlasMap = null;
|
|
UIAtlas atlas = null;
|
|
UISpriteData spData = null;
|
|
Rect _rect;
|
|
for (int i = 0; i < packSprites.Count; i++) {
|
|
m = packSprites [i] as Hashtable;
|
|
_rect = packRects [i];
|
|
d = MapEx.getMap (m, "data");
|
|
atlasMap = MapEx.getMap (m, "atlas");
|
|
foreach (DictionaryEntry item in atlasMap) {
|
|
atlas = getAtlasByName (item.Key.ToString ());
|
|
if (atlas == null) {
|
|
Debug.LogError ("Get atlas is null!!==" + item.Key);
|
|
continue;
|
|
}
|
|
|
|
// spData = atlas.GetSprite (MapEx.getString (d, "name"));
|
|
string spName = MapEx.getString (d, "name");
|
|
if (!atlas.spriteMap.ContainsKey (spName)) {
|
|
Debug.LogError ("atlas.GetSprite is null!!==" + spName);
|
|
continue;
|
|
}
|
|
int index = MapEx.getInt (atlas.spriteMap, spName);
|
|
spData = atlas.spriteList [index];
|
|
if (spData == null) {
|
|
Debug.LogError ("atlas.GetSprite is null!!==" + spName);
|
|
continue;
|
|
}
|
|
string toPath = texturePath + "/" + spData.path.Replace (CLPathCfg.self.basePath + "/upgradeRes4Dev/other/", "");
|
|
Directory.CreateDirectory (Path.GetDirectoryName (toPath));
|
|
toPath = toPath.Replace (Application.dataPath + "/", "");
|
|
AssetDatabase.ImportAsset (Path.GetDirectoryName ("Assets/" + toPath));
|
|
string err = AssetDatabase.MoveAsset ("Assets/" + spData.path, "Assets/" + toPath);
|
|
if (!string.IsNullOrEmpty (err)) {
|
|
Debug.LogError (err);
|
|
}
|
|
if (removePublishRes) {
|
|
string fromPath = Path.GetDirectoryName (spData.path) + "/Android/" + Path.GetFileNameWithoutExtension (spData.path) + ".unity3d";
|
|
fromPath = fromPath.Replace ("/upgradeRes4Dev/", "/upgradeRes4Publish/");
|
|
if (File.Exists (Application.dataPath + "/" + fromPath)) {
|
|
File.Delete (Application.dataPath + "/" + fromPath);
|
|
}
|
|
|
|
fromPath = Path.GetDirectoryName (spData.path) + "/IOS/" + Path.GetFileNameWithoutExtension (spData.path) + ".unity3d";
|
|
fromPath = fromPath.Replace ("/upgradeRes4Dev/", "/upgradeRes4Publish/");
|
|
if (File.Exists (Application.dataPath + "/" + fromPath)) {
|
|
File.Delete (Application.dataPath + "/" + fromPath);
|
|
}
|
|
}
|
|
spData.path = packTextureFile4Atlas;
|
|
spData.x = Mathf.RoundToInt (_rect.x);
|
|
spData.y = Mathf.RoundToInt (_rect.y);
|
|
|
|
EditorUtility.SetDirty (atlas.gameObject);
|
|
AssetDatabase.ImportAsset (AssetDatabase.GetAssetPath (atlas.gameObject));
|
|
}
|
|
}
|
|
AssetDatabase.SaveAssets ();
|
|
AssetDatabase.Refresh (ImportAssetOptions.ForceSynchronousImport);
|
|
|
|
|
|
EditorUtility.DisplayDialog ("success", "Finished!", "Okay");
|
|
}
|
|
|
|
UIAtlas getAtlasByName (string atlasName)
|
|
{
|
|
string tmpPath = PStr.begin ()
|
|
.a ("Assets/").a (CLPathCfg.self.basePath).a ("/").a ("upgradeRes4Dev").
|
|
a ("/priority/atlas/").a (atlasName).a (".prefab").end ();
|
|
UnityEngine.Object obj = AssetDatabase.LoadAssetAtPath (tmpPath, typeof(UnityEngine.Object));
|
|
if (obj != null) {
|
|
return ((GameObject)obj).GetComponent<UIAtlas> ();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
bool packTextures (int maxSize, bool unityPacking)//, ref ArrayList outSprites, ref Rect[] rects)
|
|
{
|
|
if (packTex != null) {
|
|
DestroyImmediate (packTex, true);
|
|
packTex = null;
|
|
}
|
|
|
|
refreshSelectedCount ();
|
|
if (selectedCount == 0) {
|
|
Debug.LogError ("Please select some sprites, that need packe");
|
|
return false;
|
|
}
|
|
|
|
packSprites.Clear ();
|
|
List<Texture2D> listTexs = new List<Texture2D> ();
|
|
for (int i = 0; i < mSpriteList.Count; i++) {
|
|
Hashtable m = mSpriteList [i] as Hashtable;
|
|
if (MapEx.getBool (m, "selected")) {
|
|
Hashtable d = MapEx.getMap (m, "data");
|
|
string name = MapEx.getString (d, "name");
|
|
string path = MapEx.getString (d, "path");
|
|
Texture2D tex = ECLEditorUtl.getObjectByPath (path) as Texture2D;
|
|
listTexs.Add (tex);
|
|
packSprites.Add (m);
|
|
}
|
|
}
|
|
if (sortSprite != SortSprite.none) {
|
|
if (sortSprite == SortSprite.SortArea) {
|
|
packSprites.Sort (CompareSprite);
|
|
} else {
|
|
packSprites.Sort (CompareSprite2);
|
|
}
|
|
listTexs.Clear ();
|
|
for (int i = 0; i < packSprites.Count; i++) {
|
|
Hashtable d = MapEx.getMap (packSprites [i], "data");
|
|
string path = MapEx.getString (d, "path");
|
|
setTextureReadable ("Assets/" + path, TextureImporterFormat.RGBA32, TextureImporterCompression.Uncompressed, true);
|
|
Texture2D tex = ECLEditorUtl.getObjectByPath (path) as Texture2D;
|
|
listTexs.Add (tex);
|
|
}
|
|
}
|
|
|
|
// for (int i = 0; i < listTexs.Count; i++) {
|
|
// setTextureReadable (listTexs [i] as Texture, TextureImporterFormat.RGBA32, TextureImporterCompression.Uncompressed, true);
|
|
// }
|
|
packTex = new Texture2D (1, 1, TextureFormat.ARGB32, false);
|
|
|
|
if (unityPacking) {
|
|
packRects = packTex.PackTextures (listTexs.ToArray (), NGUISettings.atlasPadding, maxSize);
|
|
} else {
|
|
packRects = UITexturePacker.PackTextures (packTex, listTexs.ToArray (), 4, 4, NGUISettings.atlasPadding, maxSize);
|
|
}
|
|
_empty = new Texture2D (packTex.width, packTex.height, TextureFormat.ARGB32, false);
|
|
bool ret = true;
|
|
for (int i = 0; i < listTexs.Count; ++i) {
|
|
Rect rect = NGUIMath.ConvertToPixels (packRects [i], packTex.width, packTex.height, true);
|
|
packRects [i] = rect;
|
|
|
|
// Apparently Unity can take the liberty of destroying temporary textures without any warning
|
|
if (listTexs [i] == null) {
|
|
Debug.LogWarning ("Apparently Unity can take the liberty of destroying temporary textures without any warning");
|
|
ret = false;
|
|
break;
|
|
}
|
|
|
|
// Make sure that we don't shrink the textures
|
|
if (Mathf.RoundToInt (rect.width) != listTexs [i].width) {
|
|
Debug.LogError (rect.width + "====" + listTexs [i].width);
|
|
Debug.LogWarning ("Make sure that we don't shrink the textures=" + listTexs [i].name);
|
|
ret = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// for (int i = 0; i < listTexs.Count; i++) {
|
|
// setTextureReadable (listTexs [i] as Texture, TextureImporterFormat.Automatic, false);
|
|
// }
|
|
return ret;
|
|
}
|
|
|
|
int CompareSprite (Hashtable a, Hashtable b)
|
|
{
|
|
// A is null b is not b is greater so put it at the front of the list
|
|
if (a == null && b != null)
|
|
return 1;
|
|
|
|
// A is not null b is null a is greater so put it at the front of the list
|
|
if (a != null && b == null)
|
|
return -1;
|
|
|
|
Hashtable d1 = MapEx.getMap (a, "data");
|
|
Hashtable d2 = MapEx.getMap (b, "data");
|
|
// Get the total pixels used for each sprite
|
|
int aPixels = MapEx.getInt (d1, "width") * MapEx.getInt (d1, "height");
|
|
int bPixels = MapEx.getInt (d2, "width") * MapEx.getInt (d2, "height");
|
|
|
|
if (aPixels > bPixels)
|
|
return -1;
|
|
else if (aPixels < bPixels)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
int CompareSprite2 (Hashtable a, Hashtable b)
|
|
{
|
|
// A is null b is not b is greater so put it at the front of the list
|
|
if (a == null && b != null)
|
|
return 1;
|
|
|
|
// A is not null b is null a is greater so put it at the front of the list
|
|
if (a != null && b == null)
|
|
return -1;
|
|
|
|
Hashtable d1 = MapEx.getMap (a, "data");
|
|
Hashtable d2 = MapEx.getMap (b, "data");
|
|
// Get the total pixels used for each sprite
|
|
int w = MapEx.getInt (d1, "width");
|
|
int h = MapEx.getInt (d1, "height");
|
|
int aPixels = w > h ? w : h;
|
|
w = MapEx.getInt (d2, "width");
|
|
h = MapEx.getInt (d2, "height");
|
|
int bPixels = w > h ? w : h;
|
|
|
|
if (aPixels > bPixels)
|
|
return -1;
|
|
else if (aPixels < bPixels)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
void setTextureReadable (Texture2D tex, TextureImporterFormat format, TextureImporterCompression compression, bool val, bool importNow = true)
|
|
{
|
|
string texPath = AssetDatabase.GetAssetPath (tex);
|
|
setTextureReadable (texPath, format, compression, val, importNow);
|
|
}
|
|
|
|
void setTextureReadable (string texPath, TextureImporterFormat format, TextureImporterCompression compression, bool val, bool importNow = true)
|
|
{
|
|
TextureImporter textureImporter = AssetImporter.GetAtPath (texPath) as TextureImporter;
|
|
textureImporter.isReadable = val;
|
|
|
|
//textureImporter.textureFormat = format;
|
|
textureImporter.textureCompression = compression;
|
|
TextureImporterPlatformSettings texSettings = new TextureImporterPlatformSettings();
|
|
texSettings.format = format;
|
|
texSettings.maxTextureSize = 4096;
|
|
texSettings.allowsAlphaSplitting = true;
|
|
texSettings.compressionQuality = 100;
|
|
#if UNITY_ANDROID
|
|
texSettings.name = "Android";
|
|
//textureImporter.SetPlatformTextureSettings ("Android", 4096, format, 100, true);
|
|
#elif UNITY_IPHONE || UNITY_IOS
|
|
texSettings.name = "iPhone";
|
|
//textureImporter.SetPlatformTextureSettings("iPhone", 4096, format, 100, true);
|
|
#else
|
|
texSettings.name = "Standalone";
|
|
//textureImporter.SetPlatformTextureSettings("Standalone", 4096, format, 100, true);
|
|
#endif
|
|
textureImporter.SetPlatformTextureSettings(texSettings);
|
|
EditorUtility.SetDirty (textureImporter);
|
|
textureImporter.SaveAndReimport ();
|
|
if (importNow) {
|
|
AssetDatabase.ImportAsset (texPath);
|
|
}
|
|
}
|
|
|
|
void showSpriteInfor ()
|
|
{
|
|
if (currSelectSprite == null)
|
|
return;
|
|
Hashtable d = MapEx.getMap (currSelectSprite, "data");
|
|
int times = MapEx.getInt (currSelectSprite, "times");
|
|
string name = MapEx.getString (d, "name");
|
|
string path = MapEx.getString (d, "path");
|
|
int x = MapEx.getInt (d, "x");
|
|
int y = MapEx.getInt (d, "y");
|
|
int width = MapEx.getInt (d, "width");
|
|
int height = MapEx.getInt (d, "height");
|
|
int borderLeft = MapEx.getInt (d, "borderLeft");
|
|
int borderRight = MapEx.getInt (d, "borderRight");
|
|
int borderTop = MapEx.getInt (d, "borderTop");
|
|
int borderBottom = MapEx.getInt (d, "borderBottom");
|
|
int paddingLeft = MapEx.getInt (d, "paddingLeft");
|
|
int paddingRight = MapEx.getInt (d, "paddingRight");
|
|
int paddingTop = MapEx.getInt (d, "paddingTop");
|
|
int paddingBottom = MapEx.getInt (d, "paddingBottom");
|
|
Hashtable atlas = MapEx.getMap (currSelectSprite, "atlas");
|
|
string atlasStr = "";
|
|
foreach (DictionaryEntry item in atlas) {
|
|
atlasStr = PStr.b ().a (atlasStr).a (",").a (item.Key.ToString ()).e ();
|
|
}
|
|
Texture tex = ECLEditorUtl.getObjectByPath (path) as Texture;
|
|
Rect r = Rect.zero;
|
|
if (tex != null) {
|
|
float h = 0;
|
|
float w = position.width - 160;
|
|
float rate = w / tex.width;
|
|
if (rate < 1) {
|
|
h = tex.height * rate;
|
|
} else {
|
|
h = tex.height;
|
|
}
|
|
h = h > 200 ? h : 200;
|
|
r = new Rect (0, 0, NumEx.getIntPart (w), NumEx.getIntPart (h));
|
|
GUI.DrawTexture (r, tex, ScaleMode.ScaleToFit);
|
|
GUILayout.Space (r.height + r.y); //这句主要目的是为了可以滑动
|
|
} else {
|
|
r = new Rect (0, 0, position.width - 160, 100);
|
|
GUILayout.Space (r.height + r.y); //这句主要目的是为了可以滑动
|
|
}
|
|
|
|
GUILayout.Space (10);
|
|
ECLEditorUtl.BeginContents ();
|
|
{
|
|
|
|
EditorGUILayout.BeginHorizontal ();
|
|
{
|
|
EditorGUILayout.TextField ("name", name);
|
|
EditorGUILayout.IntField ("times", times);
|
|
}
|
|
EditorGUILayout.EndHorizontal ();
|
|
|
|
EditorGUILayout.BeginHorizontal ();
|
|
{
|
|
EditorGUILayout.IntField ("x", x);
|
|
EditorGUILayout.IntField ("y", y);
|
|
}
|
|
EditorGUILayout.EndHorizontal ();
|
|
|
|
EditorGUILayout.BeginHorizontal ();
|
|
{
|
|
EditorGUILayout.IntField ("width", width);
|
|
EditorGUILayout.IntField ("height", height);
|
|
}
|
|
EditorGUILayout.EndHorizontal ();
|
|
|
|
EditorGUILayout.BeginHorizontal ();
|
|
{
|
|
EditorGUILayout.IntField ("borderLeft", borderLeft);
|
|
EditorGUILayout.IntField ("borderRight", borderRight);
|
|
}
|
|
EditorGUILayout.EndHorizontal ();
|
|
EditorGUILayout.BeginHorizontal ();
|
|
{
|
|
EditorGUILayout.IntField ("borderTop", borderTop);
|
|
EditorGUILayout.IntField ("borderBottom", borderBottom);
|
|
}
|
|
EditorGUILayout.EndHorizontal ();
|
|
EditorGUILayout.BeginHorizontal ();
|
|
{
|
|
EditorGUILayout.IntField ("paddingLeft", paddingLeft);
|
|
EditorGUILayout.IntField ("paddingRight", paddingRight);
|
|
}
|
|
EditorGUILayout.EndHorizontal ();
|
|
EditorGUILayout.BeginHorizontal ();
|
|
{
|
|
EditorGUILayout.IntField ("paddingTop", paddingTop);
|
|
EditorGUILayout.IntField ("paddingBottom", paddingBottom);
|
|
}
|
|
EditorGUILayout.EndHorizontal ();
|
|
EditorGUILayout.TextField ("path", path);
|
|
EditorGUILayout.TextField ("Atlas", atlasStr);
|
|
}
|
|
ECLEditorUtl.EndContents ();
|
|
}
|
|
|
|
void showCellSprite (Hashtable m)
|
|
{
|
|
Hashtable d = MapEx.getMap (m, "data");
|
|
Texture tex = ECLEditorUtl.getObjectByPath (MapEx.getString (d, "path")) as Texture;
|
|
if (tex == null) {
|
|
return;
|
|
}
|
|
// NGUIEditorTools.DrawTiledTexture (rect, NGUIEditorTools.backdropTexture);
|
|
Rect uv = new Rect (MapEx.getInt (d, "x"), MapEx.getInt (d, "y"), MapEx.getInt (d, "width"), MapEx.getInt (d, "height"));
|
|
uv = NGUIMath.ConvertToTexCoords (uv, tex.width, tex.height);
|
|
|
|
float scaleX = rect.width / uv.width;
|
|
float scaleY = rect.height / uv.height;
|
|
|
|
// Stretch the sprite so that it will appear proper
|
|
float aspect = (scaleY / scaleX) / ((float)tex.height / tex.width);
|
|
Rect clipRect = rect;
|
|
|
|
if (aspect != 1f) {
|
|
if (aspect < 1f) {
|
|
// The sprite is taller than it is wider
|
|
float padding = cellSize * (1f - aspect) * 0.5f;
|
|
clipRect.xMin += padding;
|
|
clipRect.xMax -= padding;
|
|
} else {
|
|
// The sprite is wider than it is taller
|
|
float padding = cellSize * (1f - 1f / aspect) * 0.5f;
|
|
clipRect.yMin += padding;
|
|
clipRect.yMax -= padding;
|
|
}
|
|
}
|
|
|
|
if (GUI.Button (rect, "")) {
|
|
mSelectedSprite = MapEx.getString (d, "name");
|
|
isShowParckerView = false;
|
|
currSelectSprite = m;
|
|
}
|
|
GUI.DrawTextureWithTexCoords (clipRect, tex, uv);
|
|
|
|
// Draw the selection
|
|
if (mSelectedSprite == MapEx.getString (d, "name")) {
|
|
NGUIEditorTools.DrawOutline (rect, new Color (0.4f, 1f, 0f, 1f));
|
|
}
|
|
|
|
GUI.backgroundColor = new Color (1f, 1f, 1f, 0.5f);
|
|
GUI.contentColor = new Color (1f, 1f, 1f, 0.7f);
|
|
GUI.Label (new Rect (rect.x, rect.y + rect.height, rect.width, 32f), MapEx.getString (d, "name"), "ProgressBarBack");
|
|
GUI.contentColor = Color.white;
|
|
GUI.backgroundColor = Color.white;
|
|
GUILayout.Space (cellSize + 30); //这句主要目的是为了可以滑动
|
|
rect.y += (cellSize + 30);
|
|
}
|
|
|
|
//=================================
|
|
/*
|
|
m.atlas[atlas.name] = atlas.name;
|
|
m.data = {};
|
|
m.data.name = spData.name;
|
|
m.data.path = spData.path;
|
|
|
|
m.data.x = spData.x;
|
|
m.data.y = spData.y;
|
|
m.data.width = spData.width;
|
|
m.data.height = spData.height;
|
|
|
|
m.data.borderLeft = spData.borderLeft
|
|
m.data.borderRight = spData.borderRight
|
|
m.data.borderTop = spData.borderTop
|
|
m.data.borderBottom = spData.borderBottom
|
|
|
|
m.data.paddingLeft = spData.paddingLeft
|
|
m.data.paddingRight = spData.paddingRight
|
|
m.data.paddingTop = spData.paddingTop
|
|
m.data.paddingBottom = spData.paddingBottom
|
|
end
|
|
m.times = m.times or 0;
|
|
m.times = m.times + 1;
|
|
|
|
*/
|
|
|
|
void initData ()
|
|
{
|
|
isShowParckerView = false;
|
|
isSelectedAll = false;
|
|
currSelectSprite = null;
|
|
packTex = null;
|
|
packRects = null;
|
|
packSprites.Clear ();
|
|
mSpriteList.Clear ();
|
|
if (string.IsNullOrEmpty (mSpritesBorrowInforFile)) {
|
|
return;
|
|
}
|
|
string content = File.ReadAllText (mSpritesBorrowInforFile);
|
|
Hashtable spriteMap = JSON.DecodeMap (content);
|
|
Hashtable m = null;
|
|
Hashtable data = null;
|
|
mSpriteList = MapEx.vals2List (spriteMap);
|
|
mSpriteList.Sort (new MySortSpriteBorrow ());
|
|
// for (int i = 0; i < mSpriteList.Count; i++) {
|
|
// m = mSpriteList [i] as Hashtable;
|
|
// data = MapEx.getMap (m, "data");
|
|
// Debug.Log (MapEx.getString (data, "name") + "," + MapEx.getInt (m, "times"));
|
|
// }
|
|
}
|
|
|
|
int sortBorrowTimes (object a, object b)
|
|
{
|
|
Hashtable m1 = a as Hashtable;
|
|
Hashtable m2 = b as Hashtable;
|
|
int ret = 0;
|
|
if (MapEx.getInt (m1, "times") > MapEx.getInt (m2, "times")) {
|
|
ret = 1;
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public class MySortSpriteBorrow : IComparer
|
|
{
|
|
// Calls CaseInsensitiveComparer.Compare with the parameters reversed.
|
|
int IComparer.Compare (object a, object b)
|
|
{
|
|
Hashtable m1 = a as Hashtable;
|
|
Hashtable m2 = b as Hashtable;
|
|
int ret = 0;
|
|
int time1 = MapEx.getInt (m1, "times");
|
|
int time2 = MapEx.getInt (m2, "times");
|
|
if (time1 < time2) {
|
|
ret = 1;
|
|
} else if (time1 == time2) {
|
|
ret = 0;
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
}
|
|
}
|