public override void OnGUI()
{
base.OnGUI();
GUILayout.BeginHorizontal();
if (NGUIEditorTools.DrawPrefixButton("Font"))
{
if (mType == UILabelInspector.FontType.NGUI)
{
ComponentSelector.Show <UIFont>(OnBitmapFont);
}
else
{
ComponentSelector.Show <Font>(OnDynamicFont);
}
}
#if DYNAMIC_FONT
GUI.changed = false;
if (mType == UILabelInspector.FontType.Unity)
{
mTrueTypeFont = (Font)EditorGUILayout.ObjectField(mTrueTypeFont, typeof(Font), false, GUILayout.Width(140f));
if (GUI.changed)
{
mBitmapFont = null;
}
}
else
{
mBitmapFont = (UIFont)EditorGUILayout.ObjectField(mBitmapFont, typeof(UIFont), false, GUILayout.Width(140f));
if (GUI.changed)
{
mTrueTypeFont = null;
}
}
mType = (UILabelInspector.FontType)EditorGUILayout.EnumPopup(mType, GUILayout.Width(62f));
#else
NGUISettings.bitmapFont = (UIFont)EditorGUILayout.ObjectField(NGUISettings.bitmapFont, typeof(UIFont), false, GUILayout.Width(140f));
mType = UILabelInspector.FontType.NGUI;
#endif
GUILayout.Label("size", GUILayout.Width(30f));
EditorGUI.BeginDisabledGroup(mType == UILabelInspector.FontType.NGUI);
NGUISettings.fontSize = EditorGUILayout.IntField(NGUISettings.fontSize, GUILayout.Width(30f));
EditorGUI.EndDisabledGroup();
GUILayout.Label("font used by the labels");
GUILayout.EndHorizontal();
NGUIEditorTools.DrawSeparator();
GameObject go = NGUIEditorTools.SelectedRoot();
if (ShouldCreate(go, go != null && (mBitmapFont != null || mTrueTypeFont != null)))
{
UINgraph pUINgraph = CreateGraphGo <UINgraph>(go);
pUINgraph.fontSize = NGUISettings.fontSize;
if (mType == UILabelInspector.FontType.NGUI)
{
pUINgraph.AxisLabelBitmapFont = mBitmapFont;
}
else
{
pUINgraph.AxisLabelDynamicFont = mTrueTypeFont;
}
}
}
/// <summary>
/// All widgets have depth, color and make pixel-perfect options
/// </summary>
protected void DrawCommonProperties()
{
PrefabType type = PrefabUtility.GetPrefabType(mWidget.gameObject);
NGUIEditorTools.DrawSeparator();
#if UNITY_3_5
// Pivot point -- old school drop-down style
UIWidget.Pivot pivot = (UIWidget.Pivot)EditorGUILayout.EnumPopup("Pivot", mWidget.pivot);
if (mWidget.pivot != pivot)
{
NGUIEditorTools.RegisterUndo("Pivot Change", mWidget);
mWidget.pivot = pivot;
}
#else
// Pivot point -- the new, more visual style
GUILayout.BeginHorizontal();
GUILayout.Label("Pivot", GUILayout.Width(76f));
Toggle("\u25C4", "ButtonLeft", UIWidget.Pivot.Left, true);
Toggle("\u25AC", "ButtonMid", UIWidget.Pivot.Center, true);
Toggle("\u25BA", "ButtonRight", UIWidget.Pivot.Right, true);
Toggle("\u25B2", "ButtonLeft", UIWidget.Pivot.Top, false);
Toggle("\u258C", "ButtonMid", UIWidget.Pivot.Center, false);
Toggle("\u25BC", "ButtonRight", UIWidget.Pivot.Bottom, false);
GUILayout.EndHorizontal();
#endif
// Depth navigation
if (type != PrefabType.Prefab)
{
GUILayout.Space(2f);
GUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel("Depth");
int depth = mWidget.depth;
if (GUILayout.Button("Back", GUILayout.Width(60f)))
{
--depth;
}
depth = EditorGUILayout.IntField(depth);
if (GUILayout.Button("Forward", GUILayout.Width(60f)))
{
++depth;
}
if (mWidget.depth != depth)
{
NGUIEditorTools.RegisterUndo("Depth Change", mWidget);
mWidget.depth = depth;
}
}
GUILayout.EndHorizontal();
int matchingDepths = 0;
for (int i = 0; i < UIWidget.list.size; ++i)
{
UIWidget w = UIWidget.list[i];
if (w != null && w.depth == mWidget.depth)
{
++matchingDepths;
}
}
if (matchingDepths > 1)
{
EditorGUILayout.HelpBox(matchingDepths + " widgets are using the depth value of " + mWidget.depth +
". It may not be clear what should be in front of what.", MessageType.Warning);
}
}
// Pixel-correctness
if (type != PrefabType.Prefab)
{
GUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel("Correction");
if (GUILayout.Button("Make Pixel-Perfect"))
{
NGUIEditorTools.RegisterUndo("Make Pixel-Perfect", mWidget.transform);
mWidget.MakePixelPerfect();
}
}
GUILayout.EndHorizontal();
}
EditorGUILayout.Space();
// Color tint
GUILayout.BeginHorizontal();
Color color = EditorGUILayout.ColorField("Color Tint", mWidget.color);
if (GUILayout.Button("Copy", GUILayout.Width(50f)))
{
NGUISettings.color = color;
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
NGUISettings.color = EditorGUILayout.ColorField("Clipboard", NGUISettings.color);
if (GUILayout.Button("Paste", GUILayout.Width(50f)))
{
color = NGUISettings.color;
}
GUILayout.EndHorizontal();
if (mWidget.color != color)
{
NGUIEditorTools.RegisterUndo("Color Change", mWidget);
mWidget.color = color;
}
}
/// <summary>
/// Draw the UI for this tool.
/// </summary>
void OnGUI()
{
bool create = false;
bool update = false;
bool replace = false;
string prefabPath = "";
string matPath = "";
// If we have an atlas to work with, see if we can figure out the path for it and its material
if (UISettings.atlas != null && UISettings.atlas.name == UISettings.atlasName)
{
prefabPath = AssetDatabase.GetAssetPath(UISettings.atlas.gameObject.GetInstanceID());
if (UISettings.atlas.spriteMaterial != null)
{
matPath = AssetDatabase.GetAssetPath(UISettings.atlas.spriteMaterial.GetInstanceID());
}
}
// Assume default values if needed
if (string.IsNullOrEmpty(UISettings.atlasName))
{
UISettings.atlasName = "New Atlas";
}
if (string.IsNullOrEmpty(prefabPath))
{
prefabPath = NGUIEditorTools.GetSelectionFolder() + UISettings.atlasName + ".prefab";
}
if (string.IsNullOrEmpty(matPath))
{
matPath = NGUIEditorTools.GetSelectionFolder() + UISettings.atlasName + ".mat";
}
// Try to load the prefab
GameObject go = AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject)) as GameObject;
if (UISettings.atlas == null && go != null)
{
UISettings.atlas = go.GetComponent <UIAtlas>();
}
EditorGUIUtility.LookLikeControls(80f);
GUILayout.Space(6f);
GUILayout.BeginHorizontal();
if (go == null)
{
GUI.backgroundColor = Color.green;
create = GUILayout.Button("Create", GUILayout.Width(76f));
}
else
{
GUI.backgroundColor = Color.red;
create = GUILayout.Button("Replace", GUILayout.Width(76f));
}
GUI.backgroundColor = Color.white;
UISettings.atlasName = GUILayout.TextField(UISettings.atlasName);
GUILayout.EndHorizontal();
if (create)
{
// If the prefab already exists, confirm that we want to overwrite it
if (go == null || EditorUtility.DisplayDialog("Are you sure?", "Are you sure you want to replace the contents of the " +
UISettings.atlasName + " atlas with the textures currently selected in the Project View? All other sprites will be deleted.", "Yes", "No"))
{
replace = true;
// Try to load the material
Material mat = AssetDatabase.LoadAssetAtPath(matPath, typeof(Material)) as Material;
// If the material doesn't exist, create it
if (mat == null)
{
Shader shader = Shader.Find("Unlit/Transparent Colored");
mat = new Material(shader);
// Save the material
AssetDatabase.CreateAsset(mat, matPath);
AssetDatabase.Refresh();
// Load the material so it's usable
mat = AssetDatabase.LoadAssetAtPath(matPath, typeof(Material)) as Material;
}
if (UISettings.atlas == null || UISettings.atlas.name != UISettings.atlasName)
{
// Create a new prefab for the atlas
#if UNITY_3_4
Object prefab = (go != null) ? go : EditorUtility.CreateEmptyPrefab(prefabPath);
#else
Object prefab = (go != null) ? go : PrefabUtility.CreateEmptyPrefab(prefabPath);
#endif
// Create a new game object for the atlas
go = new GameObject(UISettings.atlasName);
go.AddComponent <UIAtlas>().spriteMaterial = mat;
// Update the prefab
#if UNITY_3_4
EditorUtility.ReplacePrefab(go, prefab);
#else
PrefabUtility.ReplacePrefab(go, prefab);
#endif
DestroyImmediate(go);
AssetDatabase.Refresh();
// Select the atlas
go = AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject)) as GameObject;
UISettings.atlas = go.GetComponent <UIAtlas>();
}
}
}
ComponentSelector.Draw <UIAtlas>("...or select", UISettings.atlas, OnSelectAtlas);
List <Texture> textures = GetSelectedTextures();
if (UISettings.atlas != null && UISettings.atlas.name == UISettings.atlasName)
{
Material mat = UISettings.atlas.spriteMaterial;
Texture tex = UISettings.atlas.texture;
// Material information
GUILayout.BeginHorizontal();
{
if (mat != null)
{
if (GUILayout.Button("Material", GUILayout.Width(76f)))
{
Selection.activeObject = mat;
}
GUILayout.Label(" " + mat.name);
}
else
{
GUI.color = Color.grey;
GUILayout.Button("Material", GUILayout.Width(76f));
GUI.color = Color.white;
GUILayout.Label(" N/A");
}
}
GUILayout.EndHorizontal();
// Texture atlas information
GUILayout.BeginHorizontal();
{
if (tex != null)
{
if (GUILayout.Button("Texture", GUILayout.Width(76f)))
{
Selection.activeObject = tex;
}
GUILayout.Label(" " + tex.width + "x" + tex.height);
}
else
{
GUI.color = Color.grey;
GUILayout.Button("Texture", GUILayout.Width(76f));
GUI.color = Color.white;
GUILayout.Label(" N/A");
}
}
GUILayout.EndHorizontal();
// Padding and trimming
GUILayout.BeginHorizontal();
UISettings.atlasPadding = Mathf.Clamp(EditorGUILayout.IntField("Padding", UISettings.atlasPadding, GUILayout.Width(100f)), 0, 8);
UISettings.atlasTrimming = EditorGUILayout.Toggle("Trim Alpha", UISettings.atlasTrimming);
GUILayout.EndHorizontal();
if (textures.Count > 0)
{
GUI.backgroundColor = Color.green;
update = GUILayout.Button("Add/Update All");
GUI.backgroundColor = Color.white;
}
else
{
NGUIEditorTools.DrawSeparator();
GUILayout.Label("You can reveal more options by selecting\none or more textures in the Project View\nwindow.");
}
}
else
{
NGUIEditorTools.DrawSeparator();
GUILayout.Label("You can create a new atlas by selecting\none or more textures in the Project View\nwindow, then clicking \"Create\".");
}
Dictionary <string, int> spriteList = GetSpriteList(textures);
if (spriteList.Count > 0)
{
NGUIEditorTools.DrawHeader("Sprites");
GUILayout.Space(-7f);
mScroll = GUILayout.BeginScrollView(mScroll);
string delSprite = null;
int index = 0;
foreach (KeyValuePair <string, int> iter in spriteList)
{
++index;
NGUIEditorTools.HighlightLine(new Color(0.6f, 0.6f, 0.6f));
GUILayout.BeginHorizontal();
GUILayout.Label(index.ToString(), GUILayout.Width(24f));
GUILayout.Label(iter.Key);
if (iter.Value == 2)
{
GUI.color = Color.green;
GUILayout.Label("Add", GUILayout.Width(27f));
GUI.color = Color.white;
}
else if (iter.Value == 1)
{
GUI.color = Color.cyan;
GUILayout.Label("Update", GUILayout.Width(45f));
GUI.color = Color.white;
}
else
{
if (string.IsNullOrEmpty(mDelName) || mDelName != iter.Key)
{
// If we have not yet selected a sprite for deletion, show a small "X" button
if (GUILayout.Button("X", GUILayout.Width(22f)))
{
mDelName = iter.Key;
}
}
else
{
GUI.backgroundColor = Color.red;
if (GUILayout.Button("Delete", GUILayout.Width(60f)))
{
// Confirmation button clicked on -- delete this sprite
delSprite = iter.Key;
mDelName = null;
}
GUI.backgroundColor = Color.white;
}
}
GUILayout.EndHorizontal();
}
GUILayout.EndScrollView();
// If this sprite was marked for deletion, remove it from the atlas
if (!string.IsNullOrEmpty(delSprite))
{
List <UIAtlas.Sprite> list = UISettings.atlas.spriteList;
foreach (UIAtlas.Sprite sp in list)
{
if (sp.name == delSprite)
{
list.Remove(sp);
List <SpriteEntry> sprites = new List <SpriteEntry>();
ExtractSprites(UISettings.atlas, sprites);
UpdateAtlas(UISettings.atlas, sprites);
mDelName = null;
return;
}
}
}
else if (update)
{
UpdateAtlas(textures, true);
}
else if (replace)
{
UpdateAtlas(textures, false);
}
return;
}
}
public override void OnInspectorGUI()
{
mFont = target as UIFont;
RebasedEditorGUIUtility.LookLikeControls(80f);
NGUIEditorTools.DrawSeparator();
if (mFont.replacement != null)
{
mType = FontType.Reference;
mReplacement = mFont.replacement;
}
else if (mFont.dynamicFont != null)
{
mType = FontType.Dynamic;
}
GUILayout.BeginHorizontal();
FontType fontType = (FontType)EditorGUILayout.EnumPopup("Font Type", mType);
GUILayout.Space(18f);
GUILayout.EndHorizontal();
if (mType != fontType)
{
if (fontType == FontType.Normal)
{
OnSelectFont(null);
}
else
{
mType = fontType;
}
if (mType != FontType.Dynamic && mFont.dynamicFont != null)
{
mFont.dynamicFont = null;
}
}
if (mType == FontType.Reference)
{
ComponentSelector.Draw <UIFont>(mFont.replacement, OnSelectFont);
NGUIEditorTools.DrawSeparator();
EditorGUILayout.HelpBox("You can have one font simply point to " +
"another one. This is useful if you want to be " +
"able to quickly replace the contents of one " +
"font with another one, for example for " +
"swapping an SD font with an HD one, or " +
"replacing an English font with a Chinese " +
"one. All the labels referencing this font " +
"will update their references to the new one.", MessageType.Info);
if (mReplacement != mFont && mFont.replacement != mReplacement)
{
NGUIEditorTools.RegisterUndo("Font Change", mFont);
mFont.replacement = mReplacement;
UnityEditor.EditorUtility.SetDirty(mFont);
}
return;
}
else if (mType == FontType.Dynamic)
{
#if UNITY_3_5
EditorGUILayout.HelpBox("Dynamic fonts require Unity 4.0 or higher.", MessageType.Error);
#else
NGUIEditorTools.DrawSeparator();
Font fnt = EditorGUILayout.ObjectField("TTF Font", mFont.dynamicFont, typeof(Font), false) as Font;
if (fnt != mFont.dynamicFont)
{
NGUIEditorTools.RegisterUndo("Font change", mFont);
mFont.dynamicFont = fnt;
}
GUILayout.BeginHorizontal();
int size = EditorGUILayout.IntField("Size", mFont.dynamicFontSize, GUILayout.Width(120f));
FontStyle style = (FontStyle)EditorGUILayout.EnumPopup(mFont.dynamicFontStyle);
GUILayout.Space(18f);
GUILayout.EndHorizontal();
if (size != mFont.dynamicFontSize)
{
NGUIEditorTools.RegisterUndo("Font change", mFont);
mFont.dynamicFontSize = size;
}
if (style != mFont.dynamicFontStyle)
{
NGUIEditorTools.RegisterUndo("Font change", mFont);
mFont.dynamicFontStyle = style;
}
Material mat = EditorGUILayout.ObjectField("Material", mFont.material, typeof(Material), false) as Material;
if (mFont.material != mat)
{
NGUIEditorTools.RegisterUndo("Font Material", mFont);
mFont.material = mat;
}
#endif
}
else
{
NGUIEditorTools.DrawSeparator();
ComponentSelector.Draw <UIAtlas>(mFont.atlas, OnSelectAtlas);
if (mFont.atlas != null)
{
if (mFont.bmFont.isValid)
{
NGUIEditorTools.AdvancedSpriteField(mFont.atlas, mFont.spriteName, SelectSprite, false);
}
EditorGUILayout.Space();
}
else
{
// No atlas specified -- set the material and texture rectangle directly
Material mat = EditorGUILayout.ObjectField("Material", mFont.material, typeof(Material), false) as Material;
if (mFont.material != mat)
{
NGUIEditorTools.RegisterUndo("Font Material", mFont);
mFont.material = mat;
}
}
// For updating the font's data when importing from an external source, such as the texture packer
bool resetWidthHeight = false;
if (mFont.atlas != null || mFont.material != null)
{
TextAsset data = EditorGUILayout.ObjectField("Import Data", null, typeof(TextAsset), false) as TextAsset;
if (data != null)
{
NGUIEditorTools.RegisterUndo("Import Font Data", mFont);
BMFontReader.Load(mFont.bmFont, NGUITools.GetHierarchy(mFont.gameObject), data.bytes);
mFont.MarkAsDirty();
resetWidthHeight = true;
Debug.Log("Imported " + mFont.bmFont.glyphCount + " characters");
}
}
if (mFont.bmFont.isValid)
{
Color green = new Color(0.4f, 1f, 0f, 1f);
Texture2D tex = mFont.texture;
if (tex != null)
{
if (mFont.atlas == null)
{
// Pixels are easier to work with than UVs
Rect pixels = NGUIMath.ConvertToPixels(mFont.uvRect, tex.width, tex.height, false);
// Automatically set the width and height of the rectangle to be the original font texture's dimensions
if (resetWidthHeight)
{
pixels.width = mFont.texWidth;
pixels.height = mFont.texHeight;
}
// Font sprite rectangle
GUI.backgroundColor = green;
pixels = EditorGUILayout.RectField("Pixel Rect", pixels);
GUI.backgroundColor = Color.white;
// Create a button that can make the coordinates pixel-perfect on click
GUILayout.BeginHorizontal();
{
Rect corrected = NGUIMath.MakePixelPerfect(pixels);
if (corrected == pixels)
{
GUI.color = Color.grey;
GUILayout.Button("Make Pixel-Perfect");
GUI.color = Color.white;
}
else if (GUILayout.Button("Make Pixel-Perfect"))
{
pixels = corrected;
GUI.changed = true;
}
}
GUILayout.EndHorizontal();
// Convert the pixel coordinates back to UV coordinates
Rect uvRect = NGUIMath.ConvertToTexCoords(pixels, tex.width, tex.height);
if (mFont.uvRect != uvRect)
{
NGUIEditorTools.RegisterUndo("Font Pixel Rect", mFont);
mFont.uvRect = uvRect;
}
//NGUIEditorTools.DrawSeparator();
EditorGUILayout.Space();
}
}
}
}
// The font must be valid at this point for the rest of the options to show up
if (mFont.isDynamic || mFont.bmFont.isValid)
{
// Font spacing
GUILayout.BeginHorizontal();
{
RebasedEditorGUIUtility.LookLikeControls(0f);
GUILayout.Label("Spacing", GUILayout.Width(60f));
GUILayout.Label("X", GUILayout.Width(12f));
int x = EditorGUILayout.IntField(mFont.horizontalSpacing);
GUILayout.Label("Y", GUILayout.Width(12f));
int y = EditorGUILayout.IntField(mFont.verticalSpacing);
GUILayout.Space(18f);
RebasedEditorGUIUtility.LookLikeControls(80f);
if (mFont.horizontalSpacing != x || mFont.verticalSpacing != y)
{
NGUIEditorTools.RegisterUndo("Font Spacing", mFont);
mFont.horizontalSpacing = x;
mFont.verticalSpacing = y;
}
}
GUILayout.EndHorizontal();
if (mFont.atlas == null)
{
mView = View.Font;
mUseShader = false;
float pixelSize = EditorGUILayout.FloatField("Pixel Size", mFont.pixelSize, GUILayout.Width(120f));
if (pixelSize != mFont.pixelSize)
{
NGUIEditorTools.RegisterUndo("Font Change", mFont);
mFont.pixelSize = pixelSize;
}
}
EditorGUILayout.Space();
}
// Preview option
if (!mFont.isDynamic && mFont.atlas != null)
{
GUILayout.BeginHorizontal();
{
mView = (View)EditorGUILayout.EnumPopup("Preview", mView);
GUILayout.Label("Shader", GUILayout.Width(45f));
mUseShader = EditorGUILayout.Toggle(mUseShader, GUILayout.Width(20f));
}
GUILayout.EndHorizontal();
}
// Dynamic fonts don't support emoticons
if (!mFont.isDynamic && mFont.bmFont.isValid)
{
if (mFont.atlas != null)
{
NGUIEditorTools.DrawHeader("Symbols and Emoticons");
List <BMSymbol> symbols = mFont.symbols;
for (int i = 0; i < symbols.Count;)
{
BMSymbol sym = symbols[i];
GUILayout.BeginHorizontal();
GUILayout.Label(sym.sequence, GUILayout.Width(40f));
if (NGUIEditorTools.SimpleSpriteField(mFont.atlas, sym.spriteName, ChangeSymbolSprite))
{
mSelectedSymbol = sym;
}
if (GUILayout.Button("Edit", GUILayout.Width(40f)))
{
if (mFont.atlas != null)
{
NGUISettings.selectedSprite = sym.spriteName;
NGUIEditorTools.Select(mFont.atlas.gameObject);
}
}
GUI.backgroundColor = Color.red;
if (GUILayout.Button("X", GUILayout.Width(22f)))
{
NGUIEditorTools.RegisterUndo("Remove symbol", mFont);
mSymbolSequence = sym.sequence;
mSymbolSprite = sym.spriteName;
symbols.Remove(sym);
mFont.MarkAsDirty();
}
GUI.backgroundColor = Color.white;
GUILayout.EndHorizontal();
GUILayout.Space(4f);
++i;
}
if (symbols.Count > 0)
{
NGUIEditorTools.DrawSeparator();
}
GUILayout.BeginHorizontal();
mSymbolSequence = EditorGUILayout.TextField(mSymbolSequence, GUILayout.Width(40f));
NGUIEditorTools.SimpleSpriteField(mFont.atlas, mSymbolSprite, SelectSymbolSprite);
bool isValid = !string.IsNullOrEmpty(mSymbolSequence) && !string.IsNullOrEmpty(mSymbolSprite);
GUI.backgroundColor = isValid ? Color.green : Color.grey;
if (GUILayout.Button("Add", GUILayout.Width(40f)) && isValid)
{
NGUIEditorTools.RegisterUndo("Add symbol", mFont);
mFont.AddSymbol(mSymbolSequence, mSymbolSprite);
mFont.MarkAsDirty();
mSymbolSequence = "";
mSymbolSprite = "";
}
GUI.backgroundColor = Color.white;
GUILayout.EndHorizontal();
if (symbols.Count == 0)
{
EditorGUILayout.HelpBox("Want to add an emoticon to your font? In the field above type ':)', choose a sprite, then hit the Add button.", MessageType.Info);
}
else
{
GUILayout.Space(4f);
}
}
}
}
/// <summary>
/// Draw the inspector widget.
/// </summary>
public override void OnInspectorGUI()
{
UIPanel panel = target as UIPanel;
BetterList <UIDrawCall> drawcalls = panel.drawCalls;
EditorGUIUtility.LookLikeControls(80f);
NGUIEditorTools.DrawSeparator();
float alpha = EditorGUILayout.Slider("Alpha", panel.alpha, 0f, 1f);
if (alpha != panel.alpha)
{
NGUIEditorTools.RegisterUndo("Panel Alpha", panel);
panel.alpha = alpha;
}
if (panel.showInPanelTool != EditorGUILayout.Toggle("Panel Tool", panel.showInPanelTool))
{
panel.showInPanelTool = !panel.showInPanelTool;
EditorUtility.SetDirty(panel);
EditorWindow.FocusWindowIfItsOpen <UIPanelTool>();
}
GUILayout.BeginHorizontal();
bool norms = EditorGUILayout.Toggle("Normals", panel.generateNormals, GUILayout.Width(100f));
GUILayout.Label("Needed for lit shaders");
GUILayout.EndHorizontal();
if (panel.generateNormals != norms)
{
panel.generateNormals = norms;
panel.UpdateDrawcalls();
EditorUtility.SetDirty(panel);
}
GUILayout.BeginHorizontal();
bool depth = EditorGUILayout.Toggle("Depth Pass", panel.depthPass, GUILayout.Width(100f));
GUILayout.Label("Extra draw call, saves fillrate");
GUILayout.EndHorizontal();
if (panel.depthPass != depth)
{
panel.depthPass = depth;
panel.UpdateDrawcalls();
EditorUtility.SetDirty(panel);
}
GUILayout.BeginHorizontal();
bool stat = EditorGUILayout.Toggle("Static", panel.widgetsAreStatic, GUILayout.Width(100f));
GUILayout.Label("Check if widgets won't move");
GUILayout.EndHorizontal();
if (panel.widgetsAreStatic != stat)
{
panel.widgetsAreStatic = stat;
panel.UpdateDrawcalls();
EditorUtility.SetDirty(panel);
}
EditorGUILayout.LabelField("Widgets", panel.widgets.size.ToString());
EditorGUILayout.LabelField("Draw Calls", drawcalls.size.ToString());
UIPanel.DebugInfo di = (UIPanel.DebugInfo)EditorGUILayout.EnumPopup("Debug Info", panel.debugInfo);
if (panel.debugInfo != di)
{
panel.debugInfo = di;
EditorUtility.SetDirty(panel);
}
UIDrawCall.Clipping clipping = (UIDrawCall.Clipping)EditorGUILayout.EnumPopup("Clipping", panel.clipping);
if (panel.clipping != clipping)
{
panel.clipping = clipping;
EditorUtility.SetDirty(panel);
}
if (panel.clipping != UIDrawCall.Clipping.None)
{
Vector4 range = panel.clipRange;
GUILayout.BeginHorizontal();
GUILayout.Space(80f);
Vector2 pos = EditorGUILayout.Vector2Field("Center", new Vector2(range.x, range.y));
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Space(80f);
Vector2 size = EditorGUILayout.Vector2Field("Size", new Vector2(range.z, range.w));
GUILayout.EndHorizontal();
if (size.x < 0f)
{
size.x = 0f;
}
if (size.y < 0f)
{
size.y = 0f;
}
range.x = pos.x;
range.y = pos.y;
range.z = size.x;
range.w = size.y;
if (panel.clipRange != range)
{
NGUIEditorTools.RegisterUndo("Clipping Change", panel);
panel.clipRange = range;
EditorUtility.SetDirty(panel);
}
if (panel.clipping == UIDrawCall.Clipping.SoftClip)
{
GUILayout.BeginHorizontal();
GUILayout.Space(80f);
Vector2 soft = EditorGUILayout.Vector2Field("Softness", panel.clipSoftness);
GUILayout.EndHorizontal();
if (soft.x < 1f)
{
soft.x = 1f;
}
if (soft.y < 1f)
{
soft.y = 1f;
}
if (panel.clipSoftness != soft)
{
NGUIEditorTools.RegisterUndo("Clipping Change", panel);
panel.clipSoftness = soft;
EditorUtility.SetDirty(panel);
}
}
}
if (clipping == UIDrawCall.Clipping.HardClip)
{
EditorGUILayout.HelpBox("Hard clipping has been removed due to major performance issues on certain Android devices. Alpha clipping will be used instead.", MessageType.Warning);
}
if (clipping != UIDrawCall.Clipping.None && !NGUIEditorTools.IsUniform(panel.transform.lossyScale))
{
EditorGUILayout.HelpBox("Clipped panels must have a uniform scale, or clipping won't work properly!", MessageType.Error);
if (GUILayout.Button("Auto-fix"))
{
NGUIEditorTools.FixUniform(panel.gameObject);
}
}
foreach (UIDrawCall dc in drawcalls)
{
NGUIEditorTools.DrawSeparator();
EditorGUILayout.ObjectField("Material", dc.material, typeof(Material), false);
EditorGUILayout.LabelField("Triangles", dc.triangles.ToString());
if (clipping != UIDrawCall.Clipping.None && !dc.isClipped)
{
EditorGUILayout.HelpBox("You must switch this material's shader to Unlit/Transparent Colored or Unlit/Premultiplied Colored in order for clipping to work.",
MessageType.Warning);
}
}
}
override public void OnInspectorGUI()
{
mFont = target as UIFont;
EditorGUIUtility.LookLikeControls(80f);
NGUIEditorTools.DrawSeparator();
//UNISIP
if (mFont.dynamicFont != null)
{
mType = FontType.Dynamic;
}
if (mFont.replacement != null)
{
mType = FontType.Reference;
mReplacement = mFont.replacement;
}
FontType after = (FontType)EditorGUILayout.EnumPopup("Font Type", mType);
if (mType != after)
{
if (after == FontType.Normal)
{
OnSelectFont(null);
}
else
{
mType = after;
}
//UNISIP
if (mType != FontType.Dynamic && mFont.dynamicFont != null)
{
mFont.dynamicFont = null;
}
}
//UNISIP
if (mType == FontType.Dynamic)
{
//UNISIP - Draw settings for dynamic font
bool changed = false;
Font f = EditorGUILayout.ObjectField("Font", mFont.dynamicFont, typeof(Font), false) as Font;
if (f != mFont.dynamicFont)
{
mFont.dynamicFont = f;
changed = true;
}
Material mat = EditorGUILayout.ObjectField("Material", mFont.dynamicFontMaterial, typeof(Material), false) as Material;
if (mat != mFont.dynamicFontMaterial)
{
mFont.dynamicFontMaterial = mat;
changed = true;
}
if (mFont.dynamicFontMaterial == null)
{
GUILayout.Label("Warning: no coloring or clipping when using default font material");
}
int i = EditorGUILayout.IntField("Size", mFont.dynamicFontSize);
if (i != mFont.dynamicFontSize)
{
mFont.dynamicFontSize = i;
changed = true;
}
FontStyle style = (FontStyle)EditorGUILayout.EnumPopup("Style", mFont.dynamicFontStyle);
if (style != mFont.dynamicFontStyle)
{
mFont.dynamicFontStyle = style;
changed = true;
}
if (changed)
{
//force access to material property as it refreshes the texture assignment
Debug.Log("font changed...");
Material fontMat = mFont.material;
if (fontMat.mainTexture == null)
{
Debug.Log("font material texture issue...");
}
UIFont.OnFontRebuilt(mFont);
}
NGUIEditorTools.DrawSeparator();
// Font spacing
GUILayout.BeginHorizontal();
{
EditorGUIUtility.LookLikeControls(0f);
GUILayout.Label("Spacing", GUILayout.Width(60f));
GUILayout.Label("X", GUILayout.Width(12f));
int x = EditorGUILayout.IntField(mFont.horizontalSpacing);
GUILayout.Label("Y", GUILayout.Width(12f));
int y = EditorGUILayout.IntField(mFont.verticalSpacing);
EditorGUIUtility.LookLikeControls(80f);
if (mFont.horizontalSpacing != x || mFont.verticalSpacing != y)
{
NGUIEditorTools.RegisterUndo("Font Spacing", mFont);
mFont.horizontalSpacing = x;
mFont.verticalSpacing = y;
}
}
GUILayout.EndHorizontal();
}
if (mType == FontType.Reference)
{
ComponentSelector.Draw <UIFont>(mFont.replacement, OnSelectFont);
NGUIEditorTools.DrawSeparator();
GUILayout.Label("You can have one font simply point to\n" +
"another one. This is useful if you want to be\n" +
"able to quickly replace the contents of one\n" +
"font with another one, for example for\n" +
"swapping an SD font with an HD one, or\n" +
"replacing an English font with a Chinese\n" +
"one. All the labels referencing this font\n" +
"will update their references to the new one.");
if (mReplacement != mFont && mFont.replacement != mReplacement)
{
NGUIEditorTools.RegisterUndo("Font Change", mFont);
mFont.replacement = mReplacement;
UnityEditor.EditorUtility.SetDirty(mFont);
}
return;
}
if (mType != FontType.Dynamic)
{
NGUIEditorTools.DrawSeparator();
ComponentSelector.Draw <UIAtlas>(mFont.atlas, OnSelectAtlas);
if (mFont.atlas != null)
{
//if (mFont.bmFont.LegacyCheck())
//{
// Debug.Log(mFont.name + " uses a legacy font data structure. Upgrading, please save.");
// EditorUtility.SetDirty(mFont);
//}
if (mFont.bmFont.isValid)
{
NGUIEditorTools.AdvancedSpriteField(mFont.atlas, mFont.spriteName, SelectSprite, false);
}
}
else
{
// No atlas specified -- set the material and texture rectangle directly
Material mat = EditorGUILayout.ObjectField("Material", mFont.material, typeof(Material), false) as Material;
if (mFont.material != mat)
{
NGUIEditorTools.RegisterUndo("Font Material", mFont);
mFont.material = mat;
}
}
bool resetWidthHeight = false;
if (mFont.atlas != null || mFont.material != null)
{
TextAsset data = EditorGUILayout.ObjectField("Import Font", null, typeof(TextAsset), false) as TextAsset;
if (data != null)
{
NGUIEditorTools.RegisterUndo("Import Font Data", mFont);
BMFontReader.Load(mFont.bmFont, NGUITools.GetHierarchy(mFont.gameObject), data.bytes);
mFont.MarkAsDirty();
resetWidthHeight = true;
Debug.Log("Imported " + mFont.bmFont.glyphCount + " characters");
}
}
if (mFont.bmFont.isValid)
{
Color green = new Color(0.4f, 1f, 0f, 1f);
Texture2D tex = mFont.texture;
if (tex != null)
{
if (mFont.atlas == null)
{
// Pixels are easier to work with than UVs
Rect pixels = NGUIMath.ConvertToPixels(mFont.uvRect, tex.width, tex.height, false);
// Automatically set the width and height of the rectangle to be the original font texture's dimensions
if (resetWidthHeight)
{
pixels.width = mFont.texWidth;
pixels.height = mFont.texHeight;
}
// Font sprite rectangle
GUI.backgroundColor = green;
pixels = EditorGUILayout.RectField("Pixel Rect", pixels);
GUI.backgroundColor = Color.white;
// Create a button that can make the coordinates pixel-perfect on click
GUILayout.BeginHorizontal();
{
GUILayout.Label("Correction", GUILayout.Width(75f));
Rect corrected = NGUIMath.MakePixelPerfect(pixels);
if (corrected == pixels)
{
GUI.color = Color.grey;
GUILayout.Button("Make Pixel-Perfect");
GUI.color = Color.white;
}
else if (GUILayout.Button("Make Pixel-Perfect"))
{
pixels = corrected;
GUI.changed = true;
}
}
GUILayout.EndHorizontal();
// Convert the pixel coordinates back to UV coordinates
Rect uvRect = NGUIMath.ConvertToTexCoords(pixels, tex.width, tex.height);
if (mFont.uvRect != uvRect)
{
NGUIEditorTools.RegisterUndo("Font Pixel Rect", mFont);
mFont.uvRect = uvRect;
}
}
// Font spacing
GUILayout.BeginHorizontal();
{
EditorGUIUtility.LookLikeControls(0f);
GUILayout.Label("Spacing", GUILayout.Width(60f));
GUILayout.Label("X", GUILayout.Width(12f));
int x = EditorGUILayout.IntField(mFont.horizontalSpacing);
GUILayout.Label("Y", GUILayout.Width(12f));
int y = EditorGUILayout.IntField(mFont.verticalSpacing);
GUILayout.Space(62f);
EditorGUIUtility.LookLikeControls(80f);
if (mFont.horizontalSpacing != x || mFont.verticalSpacing != y)
{
NGUIEditorTools.RegisterUndo("Font Spacing", mFont);
mFont.horizontalSpacing = x;
mFont.verticalSpacing = y;
}
}
GUILayout.EndHorizontal();
if (mFont.atlas == null)
{
mView = View.Font;
mUseShader = false;
float pixelSize = EditorGUILayout.FloatField("Pixel Size", mFont.pixelSize, GUILayout.Width(120f));
if (pixelSize != mFont.pixelSize)
{
NGUIEditorTools.RegisterUndo("Font Change", mFont);
mFont.pixelSize = pixelSize;
}
}
else
{
GUILayout.Space(4f);
GUILayout.BeginHorizontal();
{
mView = (View)EditorGUILayout.EnumPopup("Preview", mView);
GUILayout.Label("Shader", GUILayout.Width(45f));
mUseShader = EditorGUILayout.Toggle(mUseShader, GUILayout.Width(20f));
}
GUILayout.EndHorizontal();
}
}
if (mFont.atlas != null)
{
NGUIEditorTools.DrawHeader("Symbols and Emoticons");
List <BMSymbol> symbols = mFont.symbols;
for (int i = 0; i < symbols.Count;)
{
BMSymbol sym = symbols[i];
GUILayout.BeginHorizontal();
GUILayout.Label(sym.sequence, GUILayout.Width(40f));
if (NGUIEditorTools.SimpleSpriteField(mFont.atlas, sym.spriteName, ChangeSymbolSprite))
{
mSelectedSymbol = sym;
}
if (GUILayout.Button("Edit", GUILayout.Width(40f)))
{
if (mFont.atlas != null)
{
EditorPrefs.SetString("NGUI Selected Sprite", sym.spriteName);
NGUIEditorTools.Select(mFont.atlas.gameObject);
}
}
GUI.backgroundColor = Color.red;
if (GUILayout.Button("X", GUILayout.Width(22f)))
{
NGUIEditorTools.RegisterUndo("Remove symbol", mFont);
mSymbolSequence = sym.sequence;
mSymbolSprite = sym.spriteName;
symbols.Remove(sym);
mFont.MarkAsDirty();
}
GUI.backgroundColor = Color.white;
GUILayout.EndHorizontal();
GUILayout.Space(4f);
++i;
}
if (symbols.Count > 0)
{
NGUIEditorTools.DrawSeparator();
}
GUILayout.BeginHorizontal();
mSymbolSequence = EditorGUILayout.TextField(mSymbolSequence, GUILayout.Width(40f));
NGUIEditorTools.SimpleSpriteField(mFont.atlas, mSymbolSprite, SelectSymbolSprite);
bool isValid = !string.IsNullOrEmpty(mSymbolSequence) && !string.IsNullOrEmpty(mSymbolSprite);
GUI.backgroundColor = isValid ? Color.green : Color.grey;
if (GUILayout.Button("Add", GUILayout.Width(40f)) && isValid)
{
NGUIEditorTools.RegisterUndo("Add symbol", mFont);
mFont.AddSymbol(mSymbolSequence, mSymbolSprite);
mFont.MarkAsDirty();
mSymbolSequence = "";
mSymbolSprite = "";
}
GUI.backgroundColor = Color.white;
GUILayout.EndHorizontal();
if (symbols.Count == 0)
{
EditorGUILayout.HelpBox("Want to add an emoticon to your font? In the field above type ':)', choose a sprite, then hit the Add button.", MessageType.Info);
}
else
{
GUILayout.Space(4f);
}
}
}
}
}
/// <summary>
/// Draw the custom wizard.
/// </summary>
void OnGUI()
{
// Load the saved preferences
if (!mLoaded)
{
mLoaded = true; Load();
}
//EditorGUIUtility.LookLikeControls(80f);
EditorGUIUtility.labelWidth = 80;
EditorGUIUtility.fieldWidth = 80;
GameObject go = NGUIEditorTools.SelectedRoot();
if (go == null)
{
GUILayout.Label("You must create a UI first.");
if (GUILayout.Button("Open the New UI Wizard"))
{
EditorWindow.GetWindow <UICreateNewUIWizard>(false, "New UI", true);
}
}
else
{
GUILayout.Space(4f);
GUILayout.BeginHorizontal();
ComponentSelector.Draw <UIAtlas>(NGUISettings.atlas, OnSelectAtlas, GUILayout.Width(140f));
GUILayout.Label("Texture atlas used by widgets", GUILayout.MinWidth(10000f));
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
ComponentSelector.Draw <UIFont>(NGUISettings.font, OnSelectFont, GUILayout.Width(140f));
GUILayout.Label("Font used by labels", GUILayout.MinWidth(10000f));
GUILayout.EndHorizontal();
GUILayout.Space(-2f);
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
WidgetType wt = (WidgetType)EditorGUILayout.EnumPopup("Template", mType, GUILayout.Width(200f));
GUILayout.Space(20f);
GUILayout.Label("Select a widget template to use");
GUILayout.EndHorizontal();
if (mType != wt)
{
mType = wt; Save();
}
switch (mType)
{
case WidgetType.Label: CreateLabel(go); break;
case WidgetType.Sprite: CreateSprite(go, mSprite); break;
case WidgetType.Texture: CreateSimpleTexture(go); break;
case WidgetType.Button: CreateButton(go); break;
case WidgetType.ImageButton: CreateImageButton(go); break;
case WidgetType.Checkbox: CreateCheckbox(go); break;
case WidgetType.ProgressBar: CreateSlider(go, false); break;
case WidgetType.Slider: CreateSlider(go, true); break;
case WidgetType.Input: CreateInput(go); break;
case WidgetType.PopupList: CreatePopup(go, true); break;
case WidgetType.PopupMenu: CreatePopup(go, false); break;
case WidgetType.ScrollBar: CreateScrollBar(go); break;
}
}
}
/// <summary>
/// All widgets have depth, color and make pixel-perfect options
/// </summary>
protected void DrawCommonProperties()
{
#if UNITY_3_4
PrefabType type = EditorUtility.GetPrefabType(mWidget.gameObject);
#else
PrefabType type = PrefabUtility.GetPrefabType(mWidget.gameObject);
#endif
NGUIEditorTools.DrawSeparator();
// Depth navigation
if (type != PrefabType.Prefab)
{
GUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel("Depth");
int depth = mWidget.depth;
if (GUILayout.Button("Back"))
{
--depth;
}
depth = EditorGUILayout.IntField(depth, GUILayout.Width(40f));
if (GUILayout.Button("Forward"))
{
++depth;
}
if (mWidget.depth != depth)
{
NGUIEditorTools.RegisterUndo("Depth Change", mWidget);
mWidget.depth = depth;
}
}
GUILayout.EndHorizontal();
}
Color color = EditorGUILayout.ColorField("Color Tint", mWidget.color);
if (mWidget.color != color)
{
NGUIEditorTools.RegisterUndo("Color Change", mWidget);
mWidget.color = color;
}
// Depth navigation
if (type != PrefabType.Prefab)
{
GUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel("Correction");
if (GUILayout.Button("Make Pixel-Perfect"))
{
NGUIEditorTools.RegisterUndo("Make Pixel-Perfect", mWidget.transform);
mWidget.MakePixelPerfect();
}
}
GUILayout.EndHorizontal();
}
UIWidget.Pivot pivot = (UIWidget.Pivot)EditorGUILayout.EnumPopup("Pivot", mWidget.pivot);
if (mWidget.pivot != pivot)
{
NGUIEditorTools.RegisterUndo("Pivot Change", mWidget);
mWidget.pivot = pivot;
}
if (mAllowPreview && mWidget.mainTexture != null)
{
GUILayout.BeginHorizontal();
{
UISettings.texturePreview = EditorGUILayout.Toggle("Preview", UISettings.texturePreview, GUILayout.Width(100f));
/*if (UISettings.texturePreview)
* {
* if (mUseShader != EditorGUILayout.Toggle("Use Shader", mUseShader))
* {
* mUseShader = !mUseShader;
*
* if (mUseShader)
* {
* // TODO: Remove this when Unity fixes the bug with DrawPreviewTexture not being affected by BeginGroup
* Debug.LogWarning("There is a bug in Unity that prevents the texture from getting clipped properly.\n" +
* "Until it's fixed by Unity, your texture may spill onto the rest of the Unity's GUI while using this mode.");
* }
* }
* }*/
}
GUILayout.EndHorizontal();
// Draw the texture last
if (UISettings.texturePreview)
{
OnDrawTexture();
}
}
}
/// <summary>
/// Draw the custom wizard.
/// </summary>
void OnGUI()
{
var panels = GetListOfPanels();
if (panels != null && panels.Count > 0)
{
mPos = EditorGUILayout.BeginScrollView(mPos);
var selectedPanel = NGUITools.FindInParents <UIPanel>(Selection.activeGameObject);
if (mExamine)
{
var ent = new Entry();
ent.panel = mExamine;
ent.isEnabled = mExamine.gameObject.activeSelf;
NGUIEditorTools.SetLabelWidth(80f);
DrawRow(null, null, ent.isEnabled);
NGUIEditorTools.DrawSeparator();
DrawRow(ent, selectedPanel, ent.isEnabled);
var dc = 0;
Material lastMat = null;
Texture lastTex = null;
Shader lastShd = null;
if (mExamine != null && mExamine.widgets != null)
{
foreach (var w in mExamine.widgets)
{
if (!NGUITools.GetActive(w.gameObject))
{
continue;
}
if (w.geometry == null || !w.geometry.hasVertices)
{
continue;
}
var mat = w.material;
var tex = w.mainTexture;
var shd = w.shader;
if (tex == null)
{
continue;
}
if (dc == 0)
{
dc = 1;
lastMat = mat;
lastTex = tex;
lastShd = shd;
}
if (lastMat != mat || lastTex != tex || lastShd != shd)
{
++dc;
lastMat = mat;
lastTex = tex;
lastShd = shd;
NGUIEditorTools.DrawThinSeparator();
}
DrawDetail(ent, w, dc);
}
}
}
else
{
// First, collect a list of panels with their associated widgets
var entries = new List <Entry>();
Entry selectedEntry = null;
var allEnabled = true;
foreach (var panel in panels)
{
var ent = new Entry();
ent.panel = panel;
ent.isEnabled = panel.gameObject.activeSelf;
if (!ent.isEnabled)
{
allEnabled = false;
}
entries.Add(ent);
}
// Sort the list by depth
entries.Sort(Compare);
mScroll = GUILayout.BeginScrollView(mScroll);
NGUIEditorTools.SetLabelWidth(80f);
bool showAll = DrawRow(null, null, allEnabled);
NGUIEditorTools.DrawSeparator();
foreach (var ent in entries)
{
if (DrawRow(ent, selectedPanel, ent.isEnabled))
{
ent.panel.gameObject.SetActive(!ent.panel.gameObject.activeSelf);
}
}
GUILayout.EndScrollView();
if (showAll)
{
foreach (Entry ent in entries)
{
ent.panel.gameObject.SetActive(!allEnabled);
}
}
else if (selectedEntry != null)
{
NGUITools.SetActive(selectedEntry.panel.gameObject, !selectedEntry.isEnabled);
}
}
EditorGUILayout.EndScrollView();
}
else
{
GUILayout.Label("No UI Panels found in the scene");
}
}
override public void OnInspectorGUI()
{
mFont = target as UIFont;
EditorGUIUtility.LookLikeControls(80f);
NGUIEditorTools.DrawSeparator();
if (mFont.replacement != null)
{
mType = FontType.Reference;
mReplacement = mFont.replacement;
}
FontType after = (FontType)EditorGUILayout.EnumPopup("Font Type", mType);
if (mType != after)
{
if (after == FontType.Normal)
{
OnSelectFont(null);
}
else
{
mType = FontType.Reference;
}
}
if (mType == FontType.Reference)
{
ComponentSelector.Draw <UIFont>(mFont.replacement, OnSelectFont);
NGUIEditorTools.DrawSeparator();
GUILayout.Label("You can have one font simply point to\n" +
"another one. This is useful if you want to be\n" +
"able to quickly replace the contents of one\n" +
"font with another one, for example for\n" +
"swapping an SD font with an HD one, or\n" +
"replacing an English font with a Chinese\n" +
"one. All the labels referencing this font\n" +
"will update their references to the new one.");
if (mReplacement != mFont && mFont.replacement != mReplacement)
{
NGUIEditorTools.RegisterUndo("Font Change", mFont);
mFont.replacement = mReplacement;
UnityEditor.EditorUtility.SetDirty(mFont);
}
return;
}
NGUIEditorTools.DrawSeparator();
ComponentSelector.Draw <UIAtlas>(mFont.atlas, OnSelectAtlas);
if (mFont.atlas != null)
{
if (mFont.bmFont.isValid)
{
NGUIEditorTools.AdvancedSpriteField(mFont.atlas, mFont.spriteName, SelectSprite, false);
}
}
else
{
// No atlas specified -- set the material and texture rectangle directly
Material mat = EditorGUILayout.ObjectField("Material", mFont.material, typeof(Material), false) as Material;
if (mFont.material != mat)
{
NGUIEditorTools.RegisterUndo("Font Material", mFont);
mFont.material = mat;
}
}
if (mFont.bmFont.isValid)
{
Color green = new Color(0.4f, 1f, 0f, 1f);
Texture2D tex = mFont.texture;
if (tex != null)
{
if (mFont.atlas == null)
{
// Pixels are easier to work with than UVs
Rect pixels = NGUIMath.ConvertToPixels(mFont.uvRect, tex.width, tex.height, false);
// Font sprite rectangle
GUI.backgroundColor = green;
pixels = EditorGUILayout.RectField("Pixel Rect", pixels);
GUI.backgroundColor = Color.white;
// Create a button that can make the coordinates pixel-perfect on click
GUILayout.BeginHorizontal();
{
GUILayout.Label("Correction", GUILayout.Width(75f));
Rect corrected = NGUIMath.MakePixelPerfect(pixels);
if (corrected == pixels)
{
GUI.color = Color.grey;
GUILayout.Button("Make Pixel-Perfect");
GUI.color = Color.white;
}
else if (GUILayout.Button("Make Pixel-Perfect"))
{
pixels = corrected;
GUI.changed = true;
}
}
GUILayout.EndHorizontal();
// Convert the pixel coordinates back to UV coordinates
Rect uvRect = NGUIMath.ConvertToTexCoords(pixels, tex.width, tex.height);
if (mFont.uvRect != uvRect)
{
NGUIEditorTools.RegisterUndo("Font Pixel Rect", mFont);
mFont.uvRect = uvRect;
}
}
// Font spacing
GUILayout.BeginHorizontal();
{
EditorGUIUtility.LookLikeControls(0f);
GUILayout.Label("Spacing", GUILayout.Width(60f));
GUILayout.Label("X", GUILayout.Width(12f));
int x = EditorGUILayout.IntField(mFont.horizontalSpacing);
GUILayout.Label("Y", GUILayout.Width(12f));
int y = EditorGUILayout.IntField(mFont.verticalSpacing);
GUILayout.Space(62f);
EditorGUIUtility.LookLikeControls(80f);
if (mFont.horizontalSpacing != x || mFont.verticalSpacing != y)
{
NGUIEditorTools.RegisterUndo("Font Spacing", mFont);
mFont.horizontalSpacing = x;
mFont.verticalSpacing = y;
}
}
GUILayout.EndHorizontal();
if (mFont.atlas == null)
{
mView = View.Font;
mUseShader = false;
float pixelSize = EditorGUILayout.FloatField("Pixel Size", mFont.pixelSize, GUILayout.Width(120f));
if (pixelSize != mFont.pixelSize)
{
NGUIEditorTools.RegisterUndo("Font Change", mFont);
mFont.pixelSize = pixelSize;
}
}
else
{
GUILayout.Space(4f);
GUILayout.BeginHorizontal();
{
mView = (View)EditorGUILayout.EnumPopup("Preview", mView);
GUILayout.Label("Shader", GUILayout.Width(45f));
mUseShader = EditorGUILayout.Toggle(mUseShader, GUILayout.Width(20f));
}
GUILayout.EndHorizontal();
}
}
if (mFont.atlas != null)
{
NGUIEditorTools.DrawHeader("Symbols and Emoticons");
List <BMSymbol> symbols = mFont.symbols;
for (int i = 0; i < symbols.Count;)
{
BMSymbol sym = symbols[i];
GUILayout.BeginHorizontal();
GUILayout.Label(sym.sequence, GUILayout.Width(40f));
if (NGUIEditorTools.SimpleSpriteField(mFont.atlas, sym.spriteName, ChangeSymbolSprite))
{
mSelectedSymbol = sym;
}
if (GUILayout.Button("Edit", GUILayout.Width(40f)))
{
if (mFont.atlas != null)
{
EditorPrefs.SetString("NGUI Selected Sprite", sym.spriteName);
NGUIEditorTools.Select(mFont.atlas.gameObject);
}
}
GUI.backgroundColor = Color.red;
if (GUILayout.Button("X", GUILayout.Width(22f)))
{
NGUIEditorTools.RegisterUndo("Remove symbol", mFont);
mSymbolSequence = sym.sequence;
mSymbolSprite = sym.spriteName;
symbols.Remove(sym);
mFont.MarkAsDirty();
}
GUI.backgroundColor = Color.white;
GUILayout.EndHorizontal();
GUILayout.Space(4f);
++i;
}
if (symbols.Count > 0)
{
NGUIEditorTools.DrawSeparator();
}
GUILayout.BeginHorizontal();
mSymbolSequence = EditorGUILayout.TextField(mSymbolSequence, GUILayout.Width(40f));
NGUIEditorTools.SimpleSpriteField(mFont.atlas, mSymbolSprite, SelectSymbolSprite);
bool isValid = !string.IsNullOrEmpty(mSymbolSequence) && !string.IsNullOrEmpty(mSymbolSprite);
GUI.backgroundColor = isValid ? Color.green : Color.grey;
if (GUILayout.Button("Add", GUILayout.Width(40f)) && isValid)
{
NGUIEditorTools.RegisterUndo("Add symbol", mFont);
mFont.AddSymbol(mSymbolSequence, mSymbolSprite);
mFont.MarkAsDirty();
mSymbolSequence = "";
mSymbolSprite = "";
}
GUI.backgroundColor = Color.white;
GUILayout.EndHorizontal();
if (symbols.Count == 0)
{
EditorGUILayout.HelpBox("Want to add an emoticon to your font? In the field above type ':)', choose a sprite, then hit the Add button.", MessageType.Info);
}
else
{
GUILayout.Space(4f);
}
}
}
}
public override void OnInspectorGUI()
{
EditorGUIUtility.LookLikeControls(80f);
UISlider slider = target as UISlider;
NGUIEditorTools.DrawSeparator();
float sliderValue = EditorGUILayout.Slider("Value", slider.sliderValue, 0f, 1f);
if (slider.sliderValue != sliderValue)
{
NGUIEditorTools.RegisterUndo("Slider Change", slider);
slider.sliderValue = sliderValue;
UnityEditor.EditorUtility.SetDirty(slider);
}
int steps = EditorGUILayout.IntSlider("Steps", slider.numberOfSteps, 0, 11);
if (slider.numberOfSteps != steps)
{
NGUIEditorTools.RegisterUndo("Slider Change", slider);
slider.numberOfSteps = steps;
slider.ForceUpdate();
UnityEditor.EditorUtility.SetDirty(slider);
}
NGUIEditorTools.DrawSeparator();
Vector2 size = slider.fullSize;
GUILayout.Label(" Size");
GUILayout.Space(-36f);
GUILayout.BeginHorizontal();
GUILayout.Space(66f);
size = EditorGUILayout.Vector2Field("", size);
GUILayout.Space(18f);
GUILayout.EndHorizontal();
if (mShowWarning && slider.foreground != null)
{
UIWidget widget = slider.foreground.GetComponent <UIWidget>();
if (widget != null && !(widget is UIFilledSprite))
{
GUI.color = new Color(1f, 0.7f, 0f);
GUILayout.Label("Don't forget to adjust the background as well");
GUILayout.Label("(the slider doesn't know what it is)");
GUI.color = Color.white;
}
}
Transform fg = EditorGUILayout.ObjectField("Foreground", slider.foreground, typeof(Transform), true) as Transform;
Transform tb = EditorGUILayout.ObjectField("Thumb", slider.thumb, typeof(Transform), true) as Transform;
UISlider.Direction dir = (UISlider.Direction)EditorGUILayout.EnumPopup("Direction", slider.direction);
// If we're using a sprite for the foreground, ensure it's using a proper pivot.
ValidatePivot(fg, "Foreground sprite", dir);
NGUIEditorTools.DrawSeparator();
GameObject er = EditorGUILayout.ObjectField("Event Recv.", slider.eventReceiver, typeof(GameObject), true) as GameObject;
GUILayout.BeginHorizontal();
string fn = EditorGUILayout.TextField("Function", slider.functionName);
GUILayout.Space(18f);
GUILayout.EndHorizontal();
if (slider.foreground != fg ||
slider.thumb != tb ||
slider.direction != dir ||
slider.fullSize != size ||
slider.eventReceiver != er ||
slider.functionName != fn)
{
if (slider.fullSize != size)
{
mShowWarning = true;
}
NGUIEditorTools.RegisterUndo("Slider Change", slider);
slider.foreground = fg;
slider.thumb = tb;
slider.direction = dir;
slider.fullSize = size;
slider.eventReceiver = er;
slider.functionName = fn;
if (slider.thumb != null)
{
slider.thumb.localPosition = Vector3.zero;
slider.sliderValue = -1f;
slider.sliderValue = sliderValue;
}
else
{
slider.ForceUpdate();
}
UnityEditor.EditorUtility.SetDirty(slider);
}
}
/// <summary>
/// Draw the inspector widget.
/// </summary>
public override void OnInspectorGUI()
{
NGUIEditorTools.DrawSeparator();
EditorGUIUtility.LookLikeControls(200f);
UISpriteAnimationPlus anim = target as UISpriteAnimationPlus;
int fps = EditorGUILayout.IntField("Framerate", anim.framesPerSecond);
fps = Mathf.Clamp(fps, 1, 60);
if (anim.framesPerSecond != fps)
{
NGUIEditorTools.RegisterUndo("Sprite Animation Change", anim);
anim.framesPerSecond = fps;
EditorUtility.SetDirty(anim);
}
string namePrefix = EditorGUILayout.TextField("Name Prefix", (anim.namePrefix != null) ? anim.namePrefix : "");
if (anim.namePrefix != namePrefix)
{
NGUIEditorTools.RegisterUndo("Sprite Animation Change", anim);
anim.namePrefix = namePrefix;
EditorUtility.SetDirty(anim);
}
UITweener.Style style = (UITweener.Style)EditorGUILayout.EnumPopup("Style", anim.style);
if (anim.style != style)
{
NGUIEditorTools.RegisterUndo("Sprite Animation Change", anim);
anim.style = style;
EditorUtility.SetDirty(anim);
}
switch (style)
{
case UITweener.Style.Once:
break;
case UITweener.Style.Loop:
case UITweener.Style.PingPong:
int loop = EditorGUILayout.IntField("Loop", anim.loop);
loop = Mathf.Max(0, loop);
if (anim.loop != loop)
{
NGUIEditorTools.RegisterUndo("Sprite Animation Change", anim);
anim.loop = loop;
EditorUtility.SetDirty(anim);
}
break;
}
bool showFirstSprite = EditorGUILayout.Toggle("Show First Sprite When End", anim.showFirstSpriteWhenEnd);
if (anim.showFirstSpriteWhenEnd != showFirstSprite)
{
NGUIEditorTools.RegisterUndo("Sprite Animation Change", anim);
anim.showFirstSpriteWhenEnd = showFirstSprite;
EditorUtility.SetDirty(anim);
}
bool hideEnd = EditorGUILayout.Toggle("Hide When End", anim.hideWhenEnd);
if (anim.hideWhenEnd != hideEnd)
{
NGUIEditorTools.RegisterUndo("Sprite Animation Change", anim);
anim.hideWhenEnd = hideEnd;
EditorUtility.SetDirty(anim);
}
// display Behavior's methods
EditorGUILayout.Space();
EditorGUIUtility.LookLikeInspector();
GUI.color = Color.cyan;
m_foldOut = EditorGUILayout.Foldout(m_foldOut, "Public Method( Can use in TimeLine):");
GUI.color = Color.white;
if (m_foldOut)
{
EditorGUILayout.BeginHorizontal();
{
GUILayout.Space(30);
GUI.color = Color.yellow;
EditorGUILayout.LabelField("Reset the animation");
GUI.color = Color.white;
EditorGUILayout.TextField("ResetSpriteAnim");
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
{
GUILayout.Space(30);
GUI.color = Color.yellow;
EditorGUILayout.LabelField("Play or pause animation(T/F)");
GUI.color = Color.white;
EditorGUILayout.TextField("PlaySpriteAnim");
}
EditorGUILayout.EndHorizontal();
}
}
/// <summary>
/// All widgets have depth, color and make pixel-perfect options
/// </summary>
protected void DrawCommonProperties()
{
#if UNITY_3_4
PrefabType type = EditorUtility.GetPrefabType(mWidget.gameObject);
#else
PrefabType type = PrefabUtility.GetPrefabType(mWidget.gameObject);
#endif
NGUIEditorTools.DrawSeparator();
// Depth navigation
if (type != PrefabType.Prefab)
{
GUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel("Depth");
int depth = mWidget.depth;
if (GUILayout.Button("Back"))
{
--depth;
}
depth = EditorGUILayout.IntField(depth, GUILayout.Width(40f));
if (GUILayout.Button("Forward"))
{
++depth;
}
if (mWidget.depth != depth)
{
NGUIEditorTools.RegisterUndo("Depth Change", mWidget);
mWidget.depth = depth;
mDepthCheck = true;
}
}
GUILayout.EndHorizontal();
UIPanel panel = mWidget.panel;
if (panel != null)
{
int count = 0;
for (int i = 0; i < panel.widgets.size; ++i)
{
UIWidget w = panel.widgets[i];
if (w != null && w.depth == mWidget.depth && w.material == mWidget.material)
{
++count;
}
}
if (count > 1)
{
EditorGUILayout.HelpBox(count + " widgets are using the depth value of " + mWidget.depth +
". It may not be clear what should be in front of what.", MessageType.Warning);
}
if (mDepthCheck)
{
if (panel.drawCalls.size > 1)
{
EditorGUILayout.HelpBox("The widgets underneath this panel are using more than one atlas. You may need to adjust transform position's Z value instead. When adjusting the Z, lower value means closer to the camera.", MessageType.Warning);
}
}
}
}
// Pivot point
UIWidget.Pivot pivot = (UIWidget.Pivot)EditorGUILayout.EnumPopup("Pivot", mWidget.pivot);
if (mWidget.pivot != pivot)
{
NGUIEditorTools.RegisterUndo("Pivot Change", mWidget);
mWidget.pivot = pivot;
}
// Pixel-correctness
if (type != PrefabType.Prefab)
{
GUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel("Correction");
if (GUILayout.Button("Make Pixel-Perfect"))
{
NGUIEditorTools.RegisterUndo("Make Pixel-Perfect", mWidget.transform);
mWidget.MakePixelPerfect();
}
}
GUILayout.EndHorizontal();
}
// Color tint
Color color = EditorGUILayout.ColorField("Color Tint", mWidget.color);
if (mWidget.color != color)
{
NGUIEditorTools.RegisterUndo("Color Change", mWidget);
mWidget.color = color;
}
}
override public void OnInspectorGUI()
{
mFont = target as UIFont;
EditorGUIUtility.LookLikeControls(80f);
NGUIEditorTools.DrawSeparator();
if (mFont.replacement != null)
{
mType = FontType.Reference;
mReplacement = mFont.replacement;
}
FontType after = (FontType)EditorGUILayout.EnumPopup("Font Type", mType);
if (mType != after)
{
if (after == FontType.Normal)
{
OnSelectFont(null);
}
else
{
mType = FontType.Reference;
}
}
if (mType == FontType.Reference)
{
ComponentSelector.Draw <UIFont>(mFont.replacement, OnSelectFont);
NGUIEditorTools.DrawSeparator();
GUILayout.Label("You can have one font simply point to\n" +
"another one. This is useful if you want to be\n" +
"able to quickly replace the contents of one\n" +
"font with another one, for example for\n" +
"swapping an SD font with an HD one, or\n" +
"replacing an English font with a Chinese\n" +
"one. All the labels referencing this font\n" +
"will update their references to the new one.");
if (mReplacement != mFont && mFont.replacement != mReplacement)
{
NGUIEditorTools.RegisterUndo("Font Change", mFont);
mFont.replacement = mReplacement;
UnityEditor.EditorUtility.SetDirty(mFont);
}
return;
}
NGUIEditorTools.DrawSeparator();
ComponentSelector.Draw <UIAtlas>(mFont.atlas, OnSelectAtlas);
if (mFont.atlas != null)
{
if (mFont.bmFont.LegacyCheck())
{
Debug.Log(mFont.name + " uses a legacy font data structure. Upgrading, please save.");
EditorUtility.SetDirty(mFont);
}
if (mFont.bmFont.isValid)
{
NGUIEditorTools.AdvancedSpriteField(mFont.atlas, mFont.spriteName, SelectSprite, false);
}
}
else
{
// No atlas specified -- set the material and texture rectangle directly
Material mat = EditorGUILayout.ObjectField("Material", mFont.material, typeof(Material), false) as Material;
if (mFont.material != mat)
{
NGUIEditorTools.RegisterUndo("Font Material", mFont);
mFont.material = mat;
}
}
bool resetWidthHeight = false;
if (mFont.atlas != null || mFont.material != null)
{
TextAsset data = EditorGUILayout.ObjectField("Import Font", null, typeof(TextAsset), false) as TextAsset;
if (data != null)
{
NGUIEditorTools.RegisterUndo("Import Font Data", mFont);
BMFontReader.Load(mFont.bmFont, NGUITools.GetHierarchy(mFont.gameObject), data.bytes);
mFont.MarkAsDirty();
resetWidthHeight = true;
Debug.Log("Imported " + mFont.bmFont.glyphCount + " characters");
}
}
if (mFont.bmFont.isValid)
{
Color green = new Color(0.4f, 1f, 0f, 1f);
Texture2D tex = mFont.texture;
if (tex != null)
{
if (mFont.atlas == null)
{
// Pixels are easier to work with than UVs
Rect pixels = NGUIMath.ConvertToPixels(mFont.uvRect, tex.width, tex.height, false);
// Automatically set the width and height of the rectangle to be the original font texture's dimensions
if (resetWidthHeight)
{
pixels.width = mFont.texWidth;
pixels.height = mFont.texHeight;
}
// Font sprite rectangle
GUI.backgroundColor = green;
pixels = EditorGUILayout.RectField("Pixel Rect", pixels);
GUI.backgroundColor = Color.white;
// Create a button that can make the coordinates pixel-perfect on click
GUILayout.BeginHorizontal();
{
GUILayout.Label("Correction", GUILayout.Width(75f));
Rect corrected = NGUIMath.MakePixelPerfect(pixels);
if (corrected == pixels)
{
GUI.color = Color.grey;
GUILayout.Button("Make Pixel-Perfect");
GUI.color = Color.white;
}
else if (GUILayout.Button("Make Pixel-Perfect"))
{
pixels = corrected;
GUI.changed = true;
}
}
GUILayout.EndHorizontal();
// Convert the pixel coordinates back to UV coordinates
Rect uvRect = NGUIMath.ConvertToTexCoords(pixels, tex.width, tex.height);
if (mFont.uvRect != uvRect)
{
NGUIEditorTools.RegisterUndo("Font Pixel Rect", mFont);
mFont.uvRect = uvRect;
}
}
// Font spacing
GUILayout.BeginHorizontal();
{
EditorGUIUtility.LookLikeControls(0f);
GUILayout.Label("Spacing", GUILayout.Width(60f));
GUILayout.Label("X", GUILayout.Width(12f));
int x = EditorGUILayout.IntField(mFont.horizontalSpacing);
GUILayout.Label("Y", GUILayout.Width(12f));
int y = EditorGUILayout.IntField(mFont.verticalSpacing);
EditorGUIUtility.LookLikeControls(80f);
if (mFont.horizontalSpacing != x || mFont.verticalSpacing != y)
{
NGUIEditorTools.RegisterUndo("Font Spacing", mFont);
mFont.horizontalSpacing = x;
mFont.verticalSpacing = y;
}
}
GUILayout.EndHorizontal();
if (mFont.atlas == null)
{
mView = View.Font;
mUseShader = false;
float pixelSize = EditorGUILayout.FloatField("Pixel Size", mFont.pixelSize, GUILayout.Width(120f));
if (pixelSize != mFont.pixelSize)
{
NGUIEditorTools.RegisterUndo("Font Change", mFont);
mFont.pixelSize = pixelSize;
}
}
else
{
GUILayout.BeginHorizontal();
{
mView = (View)EditorGUILayout.EnumPopup("Preview", mView);
GUILayout.Label("Shader", GUILayout.Width(45f));
mUseShader = EditorGUILayout.Toggle(mUseShader, GUILayout.Width(20f));
}
GUILayout.EndHorizontal();
}
}
}
}
/// <summary>
/// Draw the inspector widget.
/// </summary>
public override void OnInspectorGUI()
{
UIPanel panel = target as UIPanel;
List <UIDrawCall> drawcalls = panel.drawCalls;
#pragma warning disable 0618
EditorGUIUtility.LookLikeControls(80f);
#pragma warning restore 0618
NGUIEditorTools.DrawSeparator();
if (panel.showInPanelTool != EditorGUILayout.Toggle("Panel Tool", panel.showInPanelTool))
{
panel.showInPanelTool = !panel.showInPanelTool;
EditorUtility.SetDirty(panel);
EditorWindow.FocusWindowIfItsOpen <UIPanelTool>();
}
GUILayout.BeginHorizontal();
bool norms = EditorGUILayout.Toggle("Normals", panel.generateNormals, GUILayout.Width(100f));
GUILayout.Label("Needed for lit shaders");
GUILayout.EndHorizontal();
if (panel.generateNormals != norms)
{
panel.generateNormals = norms;
panel.UpdateDrawcalls();
EditorUtility.SetDirty(panel);
}
GUILayout.BeginHorizontal();
bool depth = EditorGUILayout.Toggle("Depth Pass", panel.depthPass, GUILayout.Width(100f));
GUILayout.Label("Extra draw call, saves fillrate");
GUILayout.EndHorizontal();
if (panel.depthPass != depth)
{
panel.depthPass = depth;
panel.UpdateDrawcalls();
EditorUtility.SetDirty(panel);
}
GUILayout.BeginHorizontal();
bool stat = EditorGUILayout.Toggle("Static", panel.widgetsAreStatic, GUILayout.Width(100f));
GUILayout.Label("Check if widgets won't move");
GUILayout.EndHorizontal();
if (panel.widgetsAreStatic != stat)
{
panel.widgetsAreStatic = stat;
panel.UpdateDrawcalls();
EditorUtility.SetDirty(panel);
}
EditorGUILayout.LabelField("Widgets", panel.widgets.Count.ToString());
EditorGUILayout.LabelField("Draw Calls", drawcalls.Count.ToString());
UIPanel.DebugInfo di = (UIPanel.DebugInfo)EditorGUILayout.EnumPopup("Debug Info", panel.debugInfo);
if (panel.debugInfo != di)
{
panel.debugInfo = di;
EditorUtility.SetDirty(panel);
}
UIDrawCall.Clipping clipping = (UIDrawCall.Clipping)EditorGUILayout.EnumPopup("Clipping", panel.clipping);
if (panel.clipping != clipping)
{
panel.clipping = clipping;
EditorUtility.SetDirty(panel);
}
if (panel.clipping != UIDrawCall.Clipping.None)
{
Vector4 range = panel.clipRange;
GUILayout.BeginHorizontal();
GUILayout.Space(80f);
Vector2 pos = EditorGUILayout.Vector2Field("Center", new Vector2(range.x, range.y));
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Space(80f);
Vector2 size = EditorGUILayout.Vector2Field("Size", new Vector2(range.z, range.w));
GUILayout.EndHorizontal();
if (size.x < 0f)
{
size.x = 0f;
}
if (size.y < 0f)
{
size.y = 0f;
}
range.x = pos.x;
range.y = pos.y;
range.z = size.x;
range.w = size.y;
if (panel.clipRange != range)
{
NGUIEditorTools.RegisterUndo("Clipping Change", panel);
panel.clipRange = range;
EditorUtility.SetDirty(panel);
}
if (panel.clipping == UIDrawCall.Clipping.SoftClip)
{
GUILayout.BeginHorizontal();
GUILayout.Space(80f);
Vector2 soft = EditorGUILayout.Vector2Field("Softness", panel.clipSoftness);
GUILayout.EndHorizontal();
if (soft.x < 1f)
{
soft.x = 1f;
}
if (soft.y < 1f)
{
soft.y = 1f;
}
if (panel.clipSoftness != soft)
{
NGUIEditorTools.RegisterUndo("Clipping Change", panel);
panel.clipSoftness = soft;
EditorUtility.SetDirty(panel);
}
}
}
foreach (UIDrawCall dc in drawcalls)
{
NGUIEditorTools.DrawSeparator();
EditorGUILayout.ObjectField("Material", dc.material, typeof(Material), false);
EditorGUILayout.LabelField("Triangles", dc.triangles.ToString());
}
}
/// <summary>
/// Draw the inspector widget.
/// </summary>
public override void OnInspectorGUI()
{
EditorGUIUtility.LookLikeControls(80f);
InvDatabase db = target as InvDatabase;
NGUIEditorTools.DrawSeparator();
InvBaseItem item = null;
if (db.items == null || db.items.Count == 0)
{
mIndex = 0;
}
else
{
mIndex = Mathf.Clamp(mIndex, 0, db.items.Count - 1);
item = db.items[mIndex];
}
if (mConfirmDelete)
{
// Show the confirmation dialog
GUILayout.Label("Are you sure you want to delete '" + item.name + "'?");
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
{
GUI.backgroundColor = Color.green;
if (GUILayout.Button("Cancel"))
{
mConfirmDelete = false;
}
GUI.backgroundColor = Color.red;
if (GUILayout.Button("Delete"))
{
NGUIEditorTools.RegisterUndo("Delete Inventory Item", db);
db.items.RemoveAt(mIndex);
mConfirmDelete = false;
}
GUI.backgroundColor = Color.white;
}
GUILayout.EndHorizontal();
}
else
{
// Database icon atlas
UIAtlas atlas = EditorGUILayout.ObjectField("Icon Atlas", db.iconAtlas, typeof(UIAtlas), false) as UIAtlas;
if (atlas != db.iconAtlas)
{
NGUIEditorTools.RegisterUndo("Databse Atlas change", db);
db.iconAtlas = atlas;
foreach (InvBaseItem i in db.items)
{
i.iconAtlas = atlas;
}
}
// Database ID
int dbID = EditorGUILayout.IntField("Database ID", db.databaseID);
if (dbID != db.databaseID)
{
NGUIEditorTools.RegisterUndo("Database ID change", db);
db.databaseID = dbID;
}
// "New" button
GUI.backgroundColor = Color.green;
if (GUILayout.Button("New Item"))
{
NGUIEditorTools.RegisterUndo("Add Inventory Item", db);
InvBaseItem bi = new InvBaseItem();
bi.iconAtlas = db.iconAtlas;
bi.id16 = (db.items.Count > 0) ? db.items[db.items.Count - 1].id16 + 1 : 0;
db.items.Add(bi);
mIndex = db.items.Count - 1;
if (item != null)
{
bi.name = "Copy of " + item.name;
bi.description = item.description;
bi.slot = item.slot;
bi.color = item.color;
bi.iconName = item.iconName;
bi.attachment = item.attachment;
bi.minItemLevel = item.minItemLevel;
bi.maxItemLevel = item.maxItemLevel;
foreach (InvStat stat in item.stats)
{
InvStat copy = new InvStat();
copy.id = stat.id;
copy.amount = stat.amount;
copy.modifier = stat.modifier;
bi.stats.Add(copy);
}
}
else
{
bi.name = "New Item";
bi.description = "Item Description";
}
item = bi;
}
GUI.backgroundColor = Color.white;
if (item != null)
{
NGUIEditorTools.DrawSeparator();
// Navigation section
GUILayout.BeginHorizontal();
{
if (mIndex == 0)
{
GUI.color = Color.grey;
}
if (GUILayout.Button("<<"))
{
mConfirmDelete = false; --mIndex;
}
GUI.color = Color.white;
mIndex = EditorGUILayout.IntField(mIndex + 1, GUILayout.Width(40f)) - 1;
GUILayout.Label("/ " + db.items.Count, GUILayout.Width(40f));
if (mIndex + 1 == db.items.Count)
{
GUI.color = Color.grey;
}
if (GUILayout.Button(">>"))
{
mConfirmDelete = false; ++mIndex;
}
GUI.color = Color.white;
}
GUILayout.EndHorizontal();
NGUIEditorTools.DrawSeparator();
// Item name and delete item button
GUILayout.BeginHorizontal();
{
string itemName = EditorGUILayout.TextField("Item Name", item.name);
GUI.backgroundColor = Color.red;
if (GUILayout.Button("Delete", GUILayout.Width(55f)))
{
mConfirmDelete = true;
}
GUI.backgroundColor = Color.white;
if (!itemName.Equals(item.name))
{
NGUIEditorTools.RegisterUndo("Rename Item", db);
item.name = itemName;
}
}
GUILayout.EndHorizontal();
string itemDesc = GUILayout.TextArea(item.description, 200, GUILayout.Height(100f));
InvBaseItem.Slot slot = (InvBaseItem.Slot)EditorGUILayout.EnumPopup("Slot", item.slot);
string iconName = "";
float iconSize = 64f;
bool drawIcon = false;
float extraSpace = 0f;
if (item.iconAtlas != null)
{
List <string> sprites = item.iconAtlas.GetListOfSprites();
sprites.Insert(0, "<None>");
int index = 0;
string spriteName = (item.iconName != null) ? item.iconName : sprites[0];
// We need to find the sprite in order to have it selected
if (!string.IsNullOrEmpty(spriteName))
{
for (int i = 1; i < sprites.Count; ++i)
{
if (spriteName.Equals(sprites[i], System.StringComparison.OrdinalIgnoreCase))
{
index = i;
break;
}
}
}
// Draw the sprite selection popup
index = EditorGUILayout.Popup("Icon", index, sprites.ToArray());
UIAtlas.Sprite sprite = (index > 0) ? item.iconAtlas.GetSprite(sprites[index]) : null;
if (sprite != null)
{
iconName = sprite.name;
Material mat = item.iconAtlas.spriteMaterial;
if (mat != null)
{
Texture2D tex = mat.mainTexture as Texture2D;
if (tex != null)
{
drawIcon = true;
Rect rect = sprite.outer;
if (item.iconAtlas.coordinates == UIAtlas.Coordinates.Pixels)
{
rect = NGUIMath.ConvertToTexCoords(rect, tex.width, tex.height);
}
GUILayout.Space(4f);
GUILayout.BeginHorizontal();
{
GUILayout.Space(Screen.width - iconSize);
NGUIEditorTools.DrawSprite(tex, rect, null);
}
GUILayout.EndHorizontal();
extraSpace = iconSize * (float)sprite.outer.height / sprite.outer.width;
}
}
}
}
// Item level range
GUILayout.BeginHorizontal();
GUILayout.Label("Level Range", GUILayout.Width(77f));
int min = EditorGUILayout.IntField(item.minItemLevel, GUILayout.MinWidth(40f));
int max = EditorGUILayout.IntField(item.maxItemLevel, GUILayout.MinWidth(40f));
if (drawIcon)
{
GUILayout.Space(iconSize);
}
GUILayout.EndHorizontal();
// Game Object attachment field, left of the icon
GUILayout.BeginHorizontal();
GameObject go = (GameObject)EditorGUILayout.ObjectField("Attachment", item.attachment, typeof(GameObject), false);
if (drawIcon)
{
GUILayout.Space(iconSize);
}
GUILayout.EndHorizontal();
// Color tint field, left of the icon
GUILayout.BeginHorizontal();
Color color = EditorGUILayout.ColorField("Color", item.color);
if (drawIcon)
{
GUILayout.Space(iconSize);
}
GUILayout.EndHorizontal();
// Calculate the extra spacing necessary for the icon to show up properly and not overlap anything
if (drawIcon)
{
extraSpace = Mathf.Max(0f, extraSpace - 60f);
GUILayout.Space(extraSpace);
}
// Item stats
NGUIEditorTools.DrawSeparator();
if (item.stats != null)
{
for (int i = 0; i < item.stats.Count; ++i)
{
InvStat stat = item.stats[i];
GUILayout.BeginHorizontal();
{
InvStat.Identifier iden = (InvStat.Identifier)EditorGUILayout.EnumPopup(stat.id, GUILayout.Width(80f));
// Color the field red if it's negative, green if it's positive
if (stat.amount > 0)
{
GUI.backgroundColor = Color.green;
}
else if (stat.amount < 0)
{
GUI.backgroundColor = Color.red;
}
int amount = EditorGUILayout.IntField(stat.amount, GUILayout.Width(40f));
GUI.backgroundColor = Color.white;
InvStat.Modifier mod = (InvStat.Modifier)EditorGUILayout.EnumPopup(stat.modifier);
GUI.backgroundColor = Color.red;
if (GUILayout.Button("X", GUILayout.Width(20f)))
{
NGUIEditorTools.RegisterUndo("Delete Item Stat", db);
item.stats.RemoveAt(i);
--i;
}
else if (iden != stat.id || amount != stat.amount || mod != stat.modifier)
{
NGUIEditorTools.RegisterUndo("Item Stats", db);
stat.id = iden;
stat.amount = amount;
stat.modifier = mod;
}
GUI.backgroundColor = Color.white;
}
GUILayout.EndHorizontal();
}
}
if (GUILayout.Button("Add Stat", GUILayout.Width(80f)))
{
NGUIEditorTools.RegisterUndo("Add Item Stat", db);
InvStat stat = new InvStat();
stat.id = InvStat.Identifier.Armor;
item.stats.Add(stat);
}
// Save all values
if (!itemDesc.Equals(item.description) ||
slot != item.slot ||
go != item.attachment ||
color != item.color ||
min != item.minItemLevel ||
max != item.maxItemLevel ||
!iconName.Equals(item.iconName))
{
NGUIEditorTools.RegisterUndo("Item Properties", db);
item.description = itemDesc;
item.slot = slot;
item.attachment = go;
item.color = color;
item.iconName = iconName;
item.minItemLevel = min;
item.maxItemLevel = max;
}
}
}
}
/// <summary>
/// Draw the custom wizard.
/// </summary>
void OnGUI()
{
// Load the saved preferences
if (!mLoaded)
{
mLoaded = true;
Load();
#if DYNAMIC_FONT
Object font = NGUISettings.ambigiousFont;
mType = ((font != null) && (font is UIFont)) ? UILabelInspector.FontType.NGUI : UILabelInspector.FontType.Unity;
#else
mType = UILabelInspector.FontType.NGUI;
#endif
}
NGUIEditorTools.SetLabelWidth(80f);
GameObject go = NGUIEditorTools.SelectedRoot();
if (go == null)
{
GUILayout.Label("You must create a UI first.");
if (GUILayout.Button("Open the New UI Wizard"))
{
EditorWindow.GetWindow <UICreateNewUIWizard>(false, "New UI", true);
}
}
else
{
GUILayout.Space(4f);
GUILayout.BeginHorizontal();
ComponentSelector.Draw <UIAtlas>(NGUISettings.atlas, OnSelectAtlas, false, GUILayout.Width(140f));
GUILayout.Label("Texture atlas used by widgets", GUILayout.Width(10000f));
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
if (NGUIEditorTools.DrawPrefixButton("Font"))
{
if (mType == UILabelInspector.FontType.NGUI)
{
ComponentSelector.Show <UIFont>(OnFont);
}
else
{
ComponentSelector.Show <Font>(OnFont, new string[] { ".ttf", ".otf" });
}
}
#if DYNAMIC_FONT
GUI.changed = false;
if (mType == UILabelInspector.FontType.Unity)
{
NGUISettings.ambigiousFont = EditorGUILayout.ObjectField(NGUISettings.ambigiousFont, typeof(Font), false, GUILayout.Width(140f));
}
else
{
NGUISettings.ambigiousFont = EditorGUILayout.ObjectField(NGUISettings.ambigiousFont, typeof(UIFont), false, GUILayout.Width(140f));
}
mType = (UILabelInspector.FontType)EditorGUILayout.EnumPopup(mType, GUILayout.Width(62f));
#else
NGUISettings.ambigiousFont = EditorGUILayout.ObjectField(NGUISettings.ambigiousFont, typeof(UIFont), false, GUILayout.Width(140f));
#endif
GUILayout.Label("size", GUILayout.Width(30f));
EditorGUI.BeginDisabledGroup(mType == UILabelInspector.FontType.NGUI);
NGUISettings.fontSize = EditorGUILayout.IntField(NGUISettings.fontSize, GUILayout.Width(30f));
EditorGUI.EndDisabledGroup();
GUILayout.Label("font used by the labels");
GUILayout.EndHorizontal();
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
WidgetType wt = (WidgetType)EditorGUILayout.EnumPopup("Template", mWidgetType, GUILayout.Width(200f));
GUILayout.Space(20f);
GUILayout.Label("Select a widget template to use");
GUILayout.EndHorizontal();
if (mWidgetType != wt)
{
mWidgetType = wt; Save();
}
switch (mWidgetType)
{
case WidgetType.Label: CreateLabel(go); break;
case WidgetType.Sprite: CreateSprite(go); break;
case WidgetType.Texture: CreateSimpleTexture(go); break;
case WidgetType.Button: CreateButton(go); break;
case WidgetType.ImageButton: CreateImageButton(go); break;
case WidgetType.Toggle: CreateToggle(go); break;
case WidgetType.ProgressBar: CreateSlider(go, false); break;
case WidgetType.Slider: CreateSlider(go, true); break;
case WidgetType.Input: CreateInput(go); break;
case WidgetType.PopupList: CreatePopup(go, true); break;
case WidgetType.PopupMenu: CreatePopup(go, false); break;
case WidgetType.ScrollBar: CreateScrollBar(go); break;
}
EditorGUILayout.HelpBox("Widget Tool has become far less useful with NGUI 3.0.6. Search the Project view for 'Control', then simply drag & drop one of them into your Scene View.", MessageType.Warning);
}
}
void OnGUI()
{
dm = (DebugManager)EditorGUILayout.ObjectField(dm, typeof(DebugManager), true);
um = (UnitSkillCamMaker)EditorGUILayout.ObjectField(um, typeof(UnitSkillCamMaker), true);
rm = (ResourceManager)EditorGUILayout.ObjectField(rm, typeof(ResourceManager), true);
NGUIEditorTools.DrawSeparator();
GUILayout.Space(10f);
GUILayout.Space(10f);
GUILayout.BeginHorizontal();
GUILayout.Space(20f);
if (GUILayout.Button("전투 에디터 모드 (디버그 & PC 데이터)"))
{
dm.useDebug = true;
rm.useAssetDownload = false;
um.useEffectSkillCamEditor = false;
um.useUnitSkillCamEditor = false;
um.useUnitSkillCamMaker = false;
um.gameResourceErrorCheck = false;
}
GUILayout.Space(20f);
GUILayout.EndHorizontal();
GUILayout.Space(10f);
GUILayout.BeginHorizontal();
GUILayout.Space(20f);
if (GUILayout.Button("실제 게임용 (인터넷 연결 & 리소스 다운로드)"))
{
dm.useDebug = false;
rm.useAssetDownload = true;
um.useEffectSkillCamEditor = false;
um.useUnitSkillCamEditor = false;
um.useUnitSkillCamMaker = false;
um.gameResourceErrorCheck = false;
}
GUILayout.Space(20f);
GUILayout.EndHorizontal();
GUILayout.Space(10f);
GUILayout.BeginHorizontal();
GUILayout.Space(20f);
if (GUILayout.Button("유닛캠 (디버그 & PC 리소스) & 에러체크"))
{
dm.useDebug = true;
rm.useAssetDownload = false;
um.useUnitSkillCamMaker = true;
um.useEffectSkillCamEditor = false;
um.useUnitSkillCamEditor = true;
um.gameResourceErrorCheck = true;
}
GUILayout.Space(20f);
GUILayout.EndHorizontal();
GUILayout.Space(10f);
GUILayout.BeginHorizontal();
GUILayout.Space(20f);
if (GUILayout.Button("이펙트 에디터 (디버그 & PC 리소스)"))
{
dm.useDebug = true;
rm.useAssetDownload = false;
um.useUnitSkillCamMaker = true;
um.useEffectSkillCamEditor = true;
um.useUnitSkillCamEditor = false;
um.gameResourceErrorCheck = false;
um.disablePlayerAttack = true;
dm.debugUnitId = new string[5];
dm.debugRoundId = "TEST";
}
GUILayout.Space(20f);
GUILayout.EndHorizontal();
GUILayout.Space(10f);
}
/// <summary>
/// All widgets have depth, color and make pixel-perfect options
/// </summary>
protected void DrawCommonProperties()
{
#if UNITY_3_4
PrefabType type = EditorUtility.GetPrefabType(mWidget.gameObject);
#else
PrefabType type = PrefabUtility.GetPrefabType(mWidget.gameObject);
#endif
NGUIEditorTools.DrawSeparator();
#if UNITY_3_5
// Pivot point -- old school drop-down style
UIWidget.Pivot pivot = (UIWidget.Pivot)EditorGUILayout.EnumPopup("Pivot", mWidget.pivot);
if (mWidget.pivot != pivot)
{
NGUIEditorTools.RegisterUndo("Pivot Change", mWidget);
mWidget.pivot = pivot;
}
#else
// Pivot point -- the new, more visual style
GUILayout.BeginHorizontal();
GUILayout.Label("Pivot", GUILayout.Width(76f));
Toggle("◄", "ButtonLeft", UIWidget.Pivot.Left, true);
Toggle("▬", "ButtonMid", UIWidget.Pivot.Center, true);
Toggle("►", "ButtonRight", UIWidget.Pivot.Right, true);
Toggle("▲", "ButtonLeft", UIWidget.Pivot.Top, false);
Toggle("▌", "ButtonMid", UIWidget.Pivot.Center, false);
Toggle("▼", "ButtonRight", UIWidget.Pivot.Bottom, false);
GUILayout.EndHorizontal();
#endif
// Depth navigation
if (type != PrefabType.Prefab)
{
GUILayout.Space(2f);
GUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel("Depth");
int depth = mWidget.depth;
if (GUILayout.Button("Back", GUILayout.Width(60f)))
{
--depth;
}
depth = EditorGUILayout.IntField(depth);
if (GUILayout.Button("Forward", GUILayout.Width(60f)))
{
++depth;
}
if (mWidget.depth != depth)
{
NGUIEditorTools.RegisterUndo("Depth Change", mWidget);
mWidget.depth = depth;
mDepthCheck = true;
}
}
GUILayout.EndHorizontal();
UIPanel panel = mWidget.panel;
if (panel != null)
{
int count = 0;
for (int i = 0; i < panel.widgets.size; ++i)
{
UIWidget w = panel.widgets[i];
if (w != null && w.depth == mWidget.depth && w.material == mWidget.material)
{
++count;
}
}
if (count > 1)
{
EditorGUILayout.HelpBox(count + " widgets are using the depth value of " + mWidget.depth +
". It may not be clear what should be in front of what.", MessageType.Warning);
}
if (mDepthCheck)
{
if (panel.drawCalls.size > 1)
{
EditorGUILayout.HelpBox("The widgets underneath this panel are using more than one atlas. You may need to adjust transform position's Z value instead. When adjusting the Z, lower value means closer to the camera.", MessageType.Warning);
}
}
}
}
// Pixel-correctness
if (type != PrefabType.Prefab)
{
GUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel("Correction");
if (GUILayout.Button("Make Pixel-Perfect"))
{
NGUIEditorTools.RegisterUndo("Make Pixel-Perfect", mWidget.transform);
mWidget.MakePixelPerfect();
}
}
GUILayout.EndHorizontal();
}
//NGUIEditorTools.DrawSeparator();
EditorGUILayout.Space();
// Color tint
GUILayout.BeginHorizontal();
Color color = EditorGUILayout.ColorField("Color Tint", mWidget.color);
if (GUILayout.Button("Copy", GUILayout.Width(50f)))
{
NGUISettings.color = color;
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
NGUISettings.color = EditorGUILayout.ColorField("Clipboard", NGUISettings.color);
if (GUILayout.Button("Paste", GUILayout.Width(50f)))
{
color = NGUISettings.color;
}
GUILayout.EndHorizontal();
if (mWidget.color != color)
{
NGUIEditorTools.RegisterUndo("Color Change", mWidget);
mWidget.color = color;
}
}
/// <summary>
/// Draw the UI for this tool.
/// </summary>
void OnGUI()
{
string prefabPath = "";
string matPath = "";
if (UISettings.font != null && UISettings.font.name == UISettings.fontName)
{
prefabPath = AssetDatabase.GetAssetPath(UISettings.font.gameObject.GetInstanceID());
if (UISettings.font.material != null)
{
matPath = AssetDatabase.GetAssetPath(UISettings.font.material.GetInstanceID());
}
}
// Assume default values if needed
if (string.IsNullOrEmpty(UISettings.fontName))
{
UISettings.fontName = "New Font";
}
if (string.IsNullOrEmpty(prefabPath))
{
prefabPath = NGUIEditorTools.GetSelectionFolder() + UISettings.fontName + ".prefab";
}
if (string.IsNullOrEmpty(matPath))
{
matPath = NGUIEditorTools.GetSelectionFolder() + UISettings.fontName + ".mat";
}
EditorGUIUtility.LookLikeControls(80f);
NGUIEditorTools.DrawHeader("Input");
UISettings.fontData = EditorGUILayout.ObjectField("Font Data", UISettings.fontData, typeof(TextAsset), false) as TextAsset;
UISettings.fontTexture = EditorGUILayout.ObjectField("Texture", UISettings.fontTexture, typeof(Texture2D), false) as Texture2D;
// Draw the atlas selection only if we have the font data and texture specified, just to make it easier
if (UISettings.fontData != null && UISettings.fontTexture != null)
{
NGUIEditorTools.DrawHeader("Output");
GUILayout.BeginHorizontal();
GUILayout.Label("Font Name", GUILayout.Width(76f));
GUI.backgroundColor = Color.white;
UISettings.fontName = GUILayout.TextField(UISettings.fontName);
GUILayout.EndHorizontal();
ComponentSelector.Draw <UIFont>("...or select", UISettings.font, OnSelectFont);
ComponentSelector.Draw <UIAtlas>(UISettings.atlas, OnSelectAtlas);
}
NGUIEditorTools.DrawSeparator();
// Helpful info
if (UISettings.fontData == null)
{
GUILayout.Label(
"The font creation mostly takes place outside\n" +
"of Unity. You can use BMFont on Windows\n" +
"or your choice of Glyph Designer or the\n" +
"less expensive bmGlyph on the Mac.\n\n" +
"Either of those tools will create a TXT for\n" +
"you that you will drag & drop into the\n" +
"field above.");
}
else if (UISettings.fontTexture == null)
{
GUILayout.Label(
"When exporting your font, you should get\n" +
"two files: the TXT, and the texture. Only\n" +
"one texture can be used per font.");
}
else if (UISettings.atlas == null)
{
GUILayout.Label(
"You can create a font that doesn't use a\n" +
"texture atlas. This will mean that the text\n" +
"labels using this font will generate an extra\n" +
"draw call, and will need to be sorted by\n" +
"adjusting the Z instead of the Depth.\n\n" +
"If you do specify an atlas, the font's texture\n" +
"will be added to it automatically.");
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUI.backgroundColor = Color.red;
bool create = GUILayout.Button("Create a Font without an Atlas", GUILayout.Width(200f));
GUI.backgroundColor = Color.white;
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
if (create)
{
GameObject go = AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject)) as GameObject;
if (go == null || EditorUtility.DisplayDialog("Are you sure?", "Are you sure you want to replace the contents of the " +
UISettings.fontName + " font with the currently selected values? This action can't be undone.", "Yes", "No"))
{
// Try to load the material
Material mat = AssetDatabase.LoadAssetAtPath(matPath, typeof(Material)) as Material;
// If the material doesn't exist, create it
if (mat == null)
{
Shader shader = Shader.Find("Unlit/Transparent Colored");
mat = new Material(shader);
// Save the material
AssetDatabase.CreateAsset(mat, matPath);
AssetDatabase.Refresh();
// Load the material so it's usable
mat = AssetDatabase.LoadAssetAtPath(matPath, typeof(Material)) as Material;
}
mat.mainTexture = UISettings.fontTexture;
if (go == null || go.GetComponent <UIFont>() == null)
{
// Create a new prefab for the atlas
#if UNITY_3_4
Object prefab = EditorUtility.CreateEmptyPrefab(prefabPath);
#else
Object prefab = PrefabUtility.CreateEmptyPrefab(prefabPath);
#endif
// Create a new game object for the font
go = new GameObject(UISettings.fontName);
UISettings.font = go.AddComponent <UIFont>();
UISettings.font.material = mat;
BMFontReader.Load(UISettings.font.bmFont, NGUITools.GetHierarchy(UISettings.font.gameObject), UISettings.fontData.bytes);
// Update the prefab
#if UNITY_3_4
EditorUtility.ReplacePrefab(go, prefab);
#else
PrefabUtility.ReplacePrefab(go, prefab);
#endif
DestroyImmediate(go);
AssetDatabase.Refresh();
// Select the atlas
go = AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject)) as GameObject;
}
UISettings.font = go.GetComponent <UIFont>();
MarkAsChanged();
}
}
}
else
{
GameObject go = AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject)) as GameObject;
bool create = false;
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (go != null)
{
if (go.GetComponent <UIFont>() != null)
{
GUI.backgroundColor = Color.red;
create = GUILayout.Button("Replace the Font", GUILayout.Width(140f));
}
else
{
GUI.backgroundColor = Color.grey;
GUILayout.Button("Rename Your Font", GUILayout.Width(140f));
}
}
else
{
GUI.backgroundColor = Color.green;
create = GUILayout.Button("Create the Font", GUILayout.Width(140f));
}
GUI.backgroundColor = Color.white;
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
if (create)
{
if (go == null || EditorUtility.DisplayDialog("Are you sure?", "Are you sure you want to replace the contents of the " +
UISettings.fontName + " font with the currently selected values? This action can't be undone.", "Yes", "No"))
{
UIAtlasMaker.AddOrUpdate(UISettings.atlas, UISettings.fontTexture);
if (go == null || go.GetComponent <UIFont>() == null)
{
// Create a new prefab for the atlas
#if UNITY_3_4
Object prefab = EditorUtility.CreateEmptyPrefab(prefabPath);
#else
Object prefab = PrefabUtility.CreateEmptyPrefab(prefabPath);
#endif
// Create a new game object for the font
go = new GameObject(UISettings.fontName);
UISettings.font = go.AddComponent <UIFont>();
UISettings.font.atlas = UISettings.atlas;
UISettings.font.spriteName = UISettings.fontTexture.name;
BMFontReader.Load(UISettings.font.bmFont, NGUITools.GetHierarchy(UISettings.font.gameObject), UISettings.fontData.bytes);
// Update the prefab
#if UNITY_3_4
EditorUtility.ReplacePrefab(go, prefab);
#else
PrefabUtility.ReplacePrefab(go, prefab);
#endif
DestroyImmediate(go);
AssetDatabase.Refresh();
// Select the atlas
go = AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject)) as GameObject;
}
else if (UISettings.fontData != null)
{
BMFontReader.Load(UISettings.font.bmFont, NGUITools.GetHierarchy(UISettings.font.gameObject), UISettings.fontData.bytes);
EditorUtility.SetDirty(UISettings.font);
UISettings.font.MarkAsDirty();
}
UISettings.font = go.GetComponent <UIFont>();
UISettings.font.spriteName = UISettings.fontTexture.name;
UISettings.font.atlas = UISettings.atlas;
MarkAsChanged();
}
}
}
}
public override void OnInspectorGUI()
{
EditorGUIUtility.LookLikeControls(80f);
mList = target as UIPopupList;
ComponentSelector.Draw <UIAtlas>(mList.atlas, OnSelectAtlas);
ComponentSelector.Draw <UIFont>(mList.font, OnSelectFont);
UILabel lbl = EditorGUILayout.ObjectField("Text Label", mList.textLabel, typeof(UILabel), true) as UILabel;
if (mList.textLabel != lbl)
{
RegisterUndo();
mList.textLabel = lbl;
if (lbl != null)
{
lbl.text = mList.selection;
}
}
if (mList.atlas != null)
{
string bg = UISpriteInspector.SpriteField(mList.atlas, "Background", mList.backgroundSprite);
string hl = UISpriteInspector.SpriteField(mList.atlas, "Highlight", mList.highlightSprite);
if (mList.backgroundSprite != bg || mList.highlightSprite != hl)
{
RegisterUndo();
mList.backgroundSprite = bg;
mList.highlightSprite = hl;
}
GUILayout.BeginHorizontal();
GUILayout.Space(6f);
GUILayout.Label("Options");
GUILayout.EndHorizontal();
string text = "";
foreach (string s in mList.items)
{
text += s + "\n";
}
GUILayout.Space(-22f);
GUILayout.BeginHorizontal();
GUILayout.Space(84f);
string modified = EditorGUILayout.TextArea(text, GUILayout.Height(100f));
GUILayout.EndHorizontal();
if (modified != text)
{
RegisterUndo();
string[] split = modified.Split(new char[] { '\n' }, System.StringSplitOptions.RemoveEmptyEntries);
mList.items.Clear();
foreach (string s in split)
{
mList.items.Add(s);
}
if (string.IsNullOrEmpty(mList.selection) || !mList.items.Contains(mList.selection))
{
mList.selection = mList.items.Count > 0 ? mList.items[0] : "";
}
}
string sel = NGUIEditorTools.DrawList("Selection", mList.items.ToArray(), mList.selection);
if (mList.selection != sel)
{
RegisterUndo();
mList.selection = sel;
}
UIPopupList.Position pos = (UIPopupList.Position)EditorGUILayout.EnumPopup("Position", mList.position);
if (mList.position != pos)
{
RegisterUndo();
mList.position = pos;
}
float ts = EditorGUILayout.FloatField("Text Scale", mList.textScale);
Color tc = EditorGUILayout.ColorField("Text Color", mList.textColor);
Color bc = EditorGUILayout.ColorField("Background", mList.backgroundColor);
Color hc = EditorGUILayout.ColorField("Highlight", mList.highlightColor);
GUILayout.BeginHorizontal();
bool isLocalized = EditorGUILayout.Toggle("Localized", mList.isLocalized, GUILayout.Width(100f));
bool isAnimated = EditorGUILayout.Toggle("Animated", mList.isAnimated);
GUILayout.EndHorizontal();
if (mList.textScale != ts ||
mList.textColor != tc ||
mList.highlightColor != hc ||
mList.backgroundColor != bc ||
mList.isLocalized != isLocalized ||
mList.isAnimated != isAnimated)
{
RegisterUndo();
mList.textScale = ts;
mList.textColor = tc;
mList.backgroundColor = bc;
mList.highlightColor = hc;
mList.isLocalized = isLocalized;
mList.isAnimated = isAnimated;
}
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
GUILayout.Space(6f);
GUILayout.Label("Padding", GUILayout.Width(76f));
GUILayout.BeginVertical();
GUILayout.Space(-12f);
Vector2 padding = EditorGUILayout.Vector2Field("", mList.padding);
GUILayout.EndVertical();
GUILayout.EndHorizontal();
if (mList.padding != padding)
{
RegisterUndo();
mList.padding = padding;
}
EditorGUIUtility.LookLikeControls(100f);
GameObject go = EditorGUILayout.ObjectField("Event Receiver", mList.eventReceiver,
typeof(GameObject), true) as GameObject;
string fn = EditorGUILayout.TextField("Function Name", mList.functionName);
if (mList.eventReceiver != go || mList.functionName != fn)
{
RegisterUndo();
mList.eventReceiver = go;
mList.functionName = fn;
}
}
}
/// <summary>
/// Draw the inspector widget.
/// </summary>
public override void OnInspectorGUI()
{
EditorGUIUtility.LookLikeControls(80f);
mAtlas = target as UIAtlas;
NGUIEditorTools.DrawSeparator();
if (mAtlas.replacement != null)
{
mType = AtlasType.Reference;
mReplacement = mAtlas.replacement;
}
AtlasType after = (AtlasType)EditorGUILayout.EnumPopup("Atlas Type", mType);
if (mType != after)
{
if (after == AtlasType.Normal)
{
OnSelectAtlas(null);
}
else
{
mType = AtlasType.Reference;
}
}
if (mType == AtlasType.Reference)
{
ComponentSelector.Draw <UIAtlas>(mAtlas.replacement, OnSelectAtlas);
NGUIEditorTools.DrawSeparator();
GUILayout.Label("You can have one atlas simply point to\n" +
"another one. This is useful if you want to be\n" +
"able to quickly replace the contents of one\n" +
"atlas with another one, for example for\n" +
"swapping an SD atlas with an HD one, or\n" +
"replacing an English atlas with a Chinese\n" +
"one. All the sprites referencing this atlas\n" +
"will update their references to the new one.");
if (mReplacement != mAtlas && mAtlas.replacement != mReplacement)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.replacement = mReplacement;
UnityEditor.EditorUtility.SetDirty(mAtlas);
}
return;
}
if (!mConfirmDelete)
{
NGUIEditorTools.DrawSeparator();
Material mat = EditorGUILayout.ObjectField("Material", mAtlas.spriteMaterial, typeof(Material), false) as Material;
if (mAtlas.spriteMaterial != mat)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.spriteMaterial = mat;
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false);
}
mAtlas.MarkAsDirty();
mConfirmDelete = false;
}
if (mat != null)
{
TextAsset ta = EditorGUILayout.ObjectField("TP Import", null, typeof(TextAsset), false) as TextAsset;
if (ta != null)
{
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false);
}
NGUIEditorTools.RegisterUndo("Import Sprites", mAtlas);
NGUIJson.LoadSpriteData(mAtlas, ta);
if (mSprite != null)
{
mSprite = mAtlas.GetSprite(mSprite.name);
}
mAtlas.MarkAsDirty();
}
UIAtlas.Coordinates coords = (UIAtlas.Coordinates)EditorGUILayout.EnumPopup("Coordinates", mAtlas.coordinates);
if (coords != mAtlas.coordinates)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.coordinates = coords;
mConfirmDelete = false;
}
}
}
if (mAtlas.spriteMaterial != null)
{
Color blue = new Color(0f, 0.7f, 1f, 1f);
Color green = new Color(0.4f, 1f, 0f, 1f);
if (mConfirmDelete)
{
if (mSprite != null)
{
// Show the confirmation dialog
NGUIEditorTools.DrawSeparator();
GUILayout.Label("Are you sure you want to delete '" + mSprite.name + "'?");
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
{
GUI.backgroundColor = Color.green;
if (GUILayout.Button("Cancel"))
{
mConfirmDelete = false;
}
GUI.backgroundColor = Color.red;
if (GUILayout.Button("Delete"))
{
NGUIEditorTools.RegisterUndo("Delete Sprite", mAtlas);
mAtlas.spriteList.Remove(mSprite);
mConfirmDelete = false;
}
GUI.backgroundColor = Color.white;
}
GUILayout.EndHorizontal();
}
else
{
mConfirmDelete = false;
}
}
else
{
if (mSprite == null && mAtlas.spriteList.Count > 0)
{
string spriteName = PlayerPrefs.GetString("NGUI Selected Sprite");
if (!string.IsNullOrEmpty(spriteName))
{
mSprite = mAtlas.GetSprite(spriteName);
}
if (mSprite == null)
{
mSprite = mAtlas.spriteList[0];
}
}
GUI.backgroundColor = Color.green;
GUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel("Add/Delete");
if (GUILayout.Button("New Sprite"))
{
NGUIEditorTools.RegisterUndo("Add Sprite", mAtlas);
UIAtlas.Sprite newSprite = new UIAtlas.Sprite();
if (mSprite != null)
{
newSprite.name = "Copy of " + mSprite.name;
newSprite.outer = mSprite.outer;
newSprite.inner = mSprite.inner;
}
else
{
newSprite.name = "New Sprite";
}
mAtlas.spriteList.Add(newSprite);
mSprite = newSprite;
}
// Show the delete button
GUI.backgroundColor = Color.red;
if (mSprite != null && GUILayout.Button("Delete", GUILayout.Width(55f)))
{
mConfirmDelete = true;
}
GUI.backgroundColor = Color.white;
}
GUILayout.EndHorizontal();
if (!mConfirmDelete && mSprite != null)
{
NGUIEditorTools.DrawSeparator();
string spriteName = UISpriteInspector.SpriteField(mAtlas, mSprite.name);
if (spriteName != mSprite.name)
{
mSprite = mAtlas.GetSprite(spriteName);
PlayerPrefs.SetString("NGUI Selected Sprite", spriteName);
}
if (mSprite == null)
{
return;
}
Texture2D tex = mAtlas.spriteMaterial.mainTexture as Texture2D;
if (tex != null)
{
Rect inner = mSprite.inner;
Rect outer = mSprite.outer;
string name = EditorGUILayout.TextField("Edit Name", mSprite.name);
if (mSprite.name != name && !string.IsNullOrEmpty(name))
{
bool found = false;
foreach (UIAtlas.Sprite sp in mAtlas.spriteList)
{
if (sp.name == name)
{
found = true;
break;
}
}
if (!found)
{
NGUIEditorTools.RegisterUndo("Edit Sprite Name", mAtlas);
mSprite.name = name;
}
}
if (mAtlas.coordinates == UIAtlas.Coordinates.Pixels)
{
GUI.backgroundColor = green;
outer = NGUIEditorTools.IntRect("Dimensions", mSprite.outer);
Vector4 border = new Vector4(
mSprite.inner.xMin - mSprite.outer.xMin,
mSprite.inner.yMin - mSprite.outer.yMin,
mSprite.outer.xMax - mSprite.inner.xMax,
mSprite.outer.yMax - mSprite.inner.yMax);
GUI.backgroundColor = blue;
border = NGUIEditorTools.IntPadding("Border", border);
GUI.backgroundColor = Color.white;
inner.xMin = mSprite.outer.xMin + border.x;
inner.yMin = mSprite.outer.yMin + border.y;
inner.xMax = mSprite.outer.xMax - border.z;
inner.yMax = mSprite.outer.yMax - border.w;
}
else
{
// Draw the inner and outer rectangle dimensions
GUI.backgroundColor = green;
outer = EditorGUILayout.RectField("Outer Rect", mSprite.outer);
GUI.backgroundColor = blue;
inner = EditorGUILayout.RectField("Inner Rect", mSprite.inner);
GUI.backgroundColor = Color.white;
}
if (outer.xMax < outer.xMin)
{
outer.xMax = outer.xMin;
}
if (outer.yMax < outer.yMin)
{
outer.yMax = outer.yMin;
}
if (outer != mSprite.outer)
{
float x = outer.xMin - mSprite.outer.xMin;
float y = outer.yMin - mSprite.outer.yMin;
inner.x += x;
inner.y += y;
}
// Sanity checks to ensure that the inner rect is always inside the outer
inner.xMin = Mathf.Clamp(inner.xMin, outer.xMin, outer.xMax);
inner.xMax = Mathf.Clamp(inner.xMax, outer.xMin, outer.xMax);
inner.yMin = Mathf.Clamp(inner.yMin, outer.yMin, outer.yMax);
inner.yMax = Mathf.Clamp(inner.yMax, outer.yMin, outer.yMax);
EditorGUILayout.Separator();
// Padding is mainly meant to be used by the 'trimmed' feature of TexturePacker
if (mAtlas.coordinates == UIAtlas.Coordinates.Pixels)
{
int left = Mathf.RoundToInt(mSprite.paddingLeft * mSprite.outer.width);
int right = Mathf.RoundToInt(mSprite.paddingRight * mSprite.outer.width);
int top = Mathf.RoundToInt(mSprite.paddingTop * mSprite.outer.height);
int bottom = Mathf.RoundToInt(mSprite.paddingBottom * mSprite.outer.height);
NGUIEditorTools.IntVector a = NGUIEditorTools.IntPair("Padding", "Left", "Top", left, top);
NGUIEditorTools.IntVector b = NGUIEditorTools.IntPair(null, "Right", "Bottom", right, bottom);
if (a.x != left || a.y != top || b.x != right || b.y != bottom)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mSprite.paddingLeft = a.x / mSprite.outer.width;
mSprite.paddingTop = a.y / mSprite.outer.width;
mSprite.paddingRight = b.x / mSprite.outer.height;
mSprite.paddingBottom = b.y / mSprite.outer.height;
MarkSpriteAsDirty();
}
}
else
{
// Create a button that can make the coordinates pixel-perfect on click
GUILayout.BeginHorizontal();
{
GUILayout.Label("Correction", GUILayout.Width(75f));
Rect corrected0 = outer;
Rect corrected1 = inner;
if (mAtlas.coordinates == UIAtlas.Coordinates.Pixels)
{
corrected0 = NGUIMath.MakePixelPerfect(corrected0);
corrected1 = NGUIMath.MakePixelPerfect(corrected1);
}
else
{
corrected0 = NGUIMath.MakePixelPerfect(corrected0, tex.width, tex.height);
corrected1 = NGUIMath.MakePixelPerfect(corrected1, tex.width, tex.height);
}
if (corrected0 == mSprite.outer && corrected1 == mSprite.inner)
{
GUI.color = Color.grey;
GUILayout.Button("Make Pixel-Perfect");
GUI.color = Color.white;
}
else if (GUILayout.Button("Make Pixel-Perfect"))
{
outer = corrected0;
inner = corrected1;
GUI.changed = true;
}
}
GUILayout.EndHorizontal();
}
GUILayout.BeginHorizontal();
{
mView = (View)EditorGUILayout.EnumPopup("Show", mView);
GUILayout.Label("Shader", GUILayout.Width(45f));
if (mUseShader != EditorGUILayout.Toggle(mUseShader, GUILayout.Width(20f)))
{
mUseShader = !mUseShader;
if (mUseShader && mView == View.Sprite)
{
// TODO: Remove this when Unity fixes the bug with DrawPreviewTexture not being affected by BeginGroup
Debug.LogWarning("There is a bug in Unity that prevents the texture from getting clipped properly.\n" +
"Until it's fixed by Unity, your texture may spill onto the rest of the Unity's GUI while using this mode.");
}
}
}
GUILayout.EndHorizontal();
if (mSprite.outer != outer || mSprite.inner != inner)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mSprite.outer = outer;
mSprite.inner = inner;
mConfirmDelete = false;
MarkSpriteAsDirty();
}
Rect uv0 = outer;
Rect uv1 = inner;
if (mAtlas.coordinates == UIAtlas.Coordinates.Pixels)
{
uv0 = NGUIMath.ConvertToTexCoords(uv0, tex.width, tex.height);
uv1 = NGUIMath.ConvertToTexCoords(uv1, tex.width, tex.height);
}
// Draw the atlas
EditorGUILayout.Separator();
Material m = mUseShader ? mAtlas.spriteMaterial : null;
Rect rect = (mView == View.Atlas) ? NGUIEditorTools.DrawAtlas(tex, m) : NGUIEditorTools.DrawSprite(tex, uv0, m);
// Draw the sprite outline
NGUIEditorTools.DrawOutline(rect, uv0, uv1);
EditorGUILayout.Separator();
}
}
}
}
}
/// <summary>
/// Draw the custom wizard.
/// </summary>
void OnGUI()
{
NGUIEditorTools.SetLabelWidth(80f);
if (NGUISettings.atlas == null)
{
GUILayout.Label("No Atlas selected.", "LODLevelNotifyText");
}
else
{
UIAtlas atlas = NGUISettings.atlas;
bool close = false;
GUILayout.Label(atlas.name + " Sprites", "LODLevelNotifyText");
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
GUILayout.Space(84f);
string before = NGUISettings.partialSprite;
string after = EditorGUILayout.TextField("", before, "SearchTextField");
if (before != after)
{
NGUISettings.partialSprite = after;
}
if (GUILayout.Button("", "SearchCancelButton", GUILayout.Width(18f)))
{
NGUISettings.partialSprite = "";
GUIUtility.keyboardControl = 0;
}
GUILayout.Space(84f);
GUILayout.EndHorizontal();
Texture2D tex = atlas.texture as Texture2D;
if (tex == null)
{
GUILayout.Label("The atlas doesn't have a texture to work with");
return;
}
BetterList <string> sprites = atlas.GetListOfSprites(NGUISettings.partialSprite);
float size = 80f;
float padded = size + 10f;
int columns = Mathf.FloorToInt(Screen.width / padded);
if (columns < 1)
{
columns = 1;
}
int offset = 0;
Rect rect = new Rect(10f, 0, size, size);
GUILayout.Space(10f);
mPos = GUILayout.BeginScrollView(mPos);
int rows = 1;
while (offset < sprites.size)
{
GUILayout.BeginHorizontal();
{
int col = 0;
rect.x = 10f;
for (; offset < sprites.size; ++offset)
{
UISpriteData sprite = atlas.GetSprite(sprites[offset]);
if (sprite == null)
{
continue;
}
// Button comes first
if (GUI.Button(rect, ""))
{
if (Event.current.button == 0)
{
float delta = Time.realtimeSinceStartup - mClickTime;
mClickTime = Time.realtimeSinceStartup;
if (NGUISettings.selectedSprite != sprite.name)
{
if (mSprite != null)
{
NGUIEditorTools.RegisterUndo("Atlas Selection", mSprite);
mSprite.MakePixelPerfect();
EditorUtility.SetDirty(mSprite.gameObject);
}
NGUISettings.selectedSprite = sprite.name;
NGUIEditorTools.RepaintSprites();
if (mCallback != null)
{
mCallback(sprite.name);
}
}
else if (delta < 0.5f)
{
close = true;
}
}
else
{
NGUIContextMenu.AddItem("Edit", false, EditSprite, sprite);
NGUIContextMenu.AddItem("Delete", false, DeleteSprite, sprite);
NGUIContextMenu.Show();
}
}
if (Event.current.type == EventType.Repaint)
{
// On top of the button we have a checkboard grid
NGUIEditorTools.DrawTiledTexture(rect, NGUIEditorTools.backdropTexture);
Rect uv = new Rect(sprite.x, sprite.y, sprite.width, sprite.height);
uv = NGUIMath.ConvertToTexCoords(uv, tex.width, tex.height);
// Calculate the texture's scale that's needed to display the sprite in the clipped area
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 = size * (1f - aspect) * 0.5f;
clipRect.xMin += padding;
clipRect.xMax -= padding;
}
else
{
// The sprite is wider than it is taller
float padding = size * (1f - 1f / aspect) * 0.5f;
clipRect.yMin += padding;
clipRect.yMax -= padding;
}
}
GUI.DrawTextureWithTexCoords(clipRect, tex, uv);
// Draw the selection
if (NGUISettings.selectedSprite == sprite.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), sprite.name, "ProgressBarBack");
GUI.contentColor = Color.white;
GUI.backgroundColor = Color.white;
if (++col >= columns)
{
++offset;
break;
}
rect.x += padded;
}
}
GUILayout.EndHorizontal();
GUILayout.Space(padded);
rect.y += padded + 26;
++rows;
}
GUILayout.Space(rows * 26);
GUILayout.EndScrollView();
if (close)
{
Close();
}
}
}
override public void OnInspectorGUI()
{
mFont = target as UIFont;
EditorGUIUtility.LookLikeControls(80f);
NGUIEditorTools.DrawSeparator();
if (mFont.replacement != null)
{
mType = FontType.Reference;
mReplacement = mFont.replacement;
}
FontType after = (FontType)EditorGUILayout.EnumPopup("Font Type", mType);
if (mType != after)
{
if (after == FontType.Normal)
{
OnSelectFont(null);
}
else
{
mType = FontType.Reference;
}
}
if (mType == FontType.Reference)
{
ComponentSelector.Draw <UIFont>(mFont.replacement, OnSelectFont);
NGUIEditorTools.DrawSeparator();
GUILayout.Label("You can have one font simply point to\n" +
"another one. This is useful if you want to be\n" +
"able to quickly replace the contents of one\n" +
"font with another one, for example for\n" +
"swapping an SD font with an HD one, or\n" +
"replacing an English font with a Chinese\n" +
"one. All the labels referencing this font\n" +
"will update their references to the new one.");
if (mReplacement != mFont && mFont.replacement != mReplacement)
{
NGUIEditorTools.RegisterUndo("Font Change", mFont);
mFont.replacement = mReplacement;
UnityEditor.EditorUtility.SetDirty(mFont);
}
return;
}
NGUIEditorTools.DrawSeparator();
ComponentSelector.Draw <UIAtlas>(mFont.atlas, OnSelectAtlas);
if (mFont.atlas != null)
{
if (mFont.bmFont.isValid)
{
string spriteName = UISlicedSpriteInspector.SpriteField(mFont.atlas, mFont.spriteName);
if (mFont.spriteName != spriteName)
{
NGUIEditorTools.RegisterUndo("Font Sprite", mFont);
mFont.spriteName = spriteName;
}
}
}
else
{
// No atlas specified -- set the material and texture rectangle directly
Material mat = EditorGUILayout.ObjectField("Material", mFont.material, typeof(Material), false) as Material;
if (mFont.material != mat)
{
NGUIEditorTools.RegisterUndo("Font Material", mFont);
mFont.material = mat;
}
}
bool resetWidthHeight = false;
if (mFont.atlas != null || mFont.material != null)
{
TextAsset data = EditorGUILayout.ObjectField("Import Font", null, typeof(TextAsset), false) as TextAsset;
if (data != null)
{
NGUIEditorTools.RegisterUndo("Import Font Data", mFont);
BMFontReader.Load(mFont.bmFont, NGUITools.GetHierarchy(mFont.gameObject), data.bytes);
mFont.MarkAsDirty();
resetWidthHeight = true;
Debug.Log("Imported " + mFont.bmFont.glyphCount + " characters");
}
}
if (mFont.bmFont.isValid)
{
Color green = new Color(0.4f, 1f, 0f, 1f);
Texture2D tex = mFont.texture;
if (tex != null)
{
if (mFont.atlas == null)
{
// Pixels are easier to work with than UVs
Rect pixels = NGUIMath.ConvertToPixels(mFont.uvRect, tex.width, tex.height, false);
// Automatically set the width and height of the rectangle to be the original font texture's dimensions
if (resetWidthHeight)
{
pixels.width = mFont.texWidth;
pixels.height = mFont.texHeight;
}
// Font sprite rectangle
GUI.backgroundColor = green;
pixels = EditorGUILayout.RectField("Pixel Rect", pixels);
GUI.backgroundColor = Color.white;
// Create a button that can make the coordinates pixel-perfect on click
GUILayout.BeginHorizontal();
{
GUILayout.Label("Correction", GUILayout.Width(75f));
Rect corrected = NGUIMath.MakePixelPerfect(pixels);
if (corrected == pixels)
{
GUI.color = Color.grey;
GUILayout.Button("Make Pixel-Perfect");
GUI.color = Color.white;
}
else if (GUILayout.Button("Make Pixel-Perfect"))
{
pixels = corrected;
GUI.changed = true;
}
}
GUILayout.EndHorizontal();
// Convert the pixel coordinates back to UV coordinates
Rect uvRect = NGUIMath.ConvertToTexCoords(pixels, tex.width, tex.height);
if (mFont.uvRect != uvRect)
{
NGUIEditorTools.RegisterUndo("Font Pixel Rect", mFont);
mFont.uvRect = uvRect;
}
}
// Font spacing
GUILayout.BeginHorizontal();
{
EditorGUIUtility.LookLikeControls(0f);
GUILayout.Label("Spacing", GUILayout.Width(60f));
GUILayout.Label("X", GUILayout.Width(12f));
int x = EditorGUILayout.IntField(mFont.horizontalSpacing);
GUILayout.Label("Y", GUILayout.Width(12f));
int y = EditorGUILayout.IntField(mFont.verticalSpacing);
EditorGUIUtility.LookLikeControls(80f);
if (mFont.horizontalSpacing != x || mFont.verticalSpacing != y)
{
NGUIEditorTools.RegisterUndo("Font Spacing", mFont);
mFont.horizontalSpacing = x;
mFont.verticalSpacing = y;
}
}
GUILayout.EndHorizontal();
EditorGUILayout.Separator();
GUILayout.BeginHorizontal();
{
mView = (View)EditorGUILayout.EnumPopup("Show", mView);
GUILayout.Label("Shader", GUILayout.Width(45f));
if (mUseShader != EditorGUILayout.Toggle(mUseShader, GUILayout.Width(20f)))
{
mUseShader = !mUseShader;
if (mUseShader && mView == View.Font)
{
// TODO: Remove this when Unity fixes the bug with DrawPreviewTexture not being affected by BeginGroup
Debug.LogWarning("There is a bug in Unity that prevents the texture from getting clipped properly.\n" +
"Until it's fixed by Unity, your texture may spill onto the rest of the Unity's GUI while using this mode.");
}
}
}
GUILayout.EndHorizontal();
if (mView != View.Nothing)
{
// Draw the atlas
EditorGUILayout.Separator();
Material m = mUseShader ? mFont.material : null;
Rect rect = (mView == View.Atlas) ? NGUIEditorTools.DrawAtlas(tex, m) : NGUIEditorTools.DrawSprite(tex, mFont.uvRect, m);
NGUIEditorTools.DrawOutline(rect, mFont.uvRect, green);
rect = GUILayoutUtility.GetRect(Screen.width, 18f);
EditorGUI.DropShadowLabel(rect, "Font Size: " + mFont.size);
}
}
}
}
/// <summary>
/// Draw the inspector widget.
/// </summary>
public override void OnInspectorGUI()
{
EditorGUIUtility.fieldWidth = 0f;
EditorGUIUtility.labelWidth = 80f;
mAtlas = target as UIAtlas;
UIAtlas.Sprite sprite = (mAtlas != null) ? mAtlas.GetSprite(NGUISettings.selectedSprite) : null;
NGUIEditorTools.DrawSeparator();
if (mAtlas.replacement != null)
{
mType = AtlasType.Reference;
mReplacement = mAtlas.replacement;
}
AtlasType after = (AtlasType)EditorGUILayout.EnumPopup("Atlas Type", mType);
if (mType != after)
{
if (after == AtlasType.Normal)
{
OnSelectAtlas(null);
}
else
{
mType = AtlasType.Reference;
}
}
if (mType == AtlasType.Reference)
{
ComponentSelector.Draw <UIAtlas>(mAtlas.replacement, OnSelectAtlas);
NGUIEditorTools.DrawSeparator();
EditorGUILayout.HelpBox("You can have one atlas simply point to " +
"another one. This is useful if you want to be " +
"able to quickly replace the contents of one " +
"atlas with another one, for example for " +
"swapping an SD atlas with an HD one, or " +
"replacing an English atlas with a Chinese " +
"one. All the sprites referencing this atlas " +
"will update their references to the new one.", MessageType.Info);
if (mReplacement != mAtlas && mAtlas.replacement != mReplacement)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.replacement = mReplacement;
UnityEditor.EditorUtility.SetDirty(mAtlas);
}
return;
}
if (!mConfirmDelete)
{
NGUIEditorTools.DrawSeparator();
Material mat = EditorGUILayout.ObjectField("Material", mAtlas.spriteMaterial, typeof(Material), false) as Material;
if (mAtlas.spriteMaterial != mat)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.spriteMaterial = mat;
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false);
}
mAtlas.MarkAsDirty();
mConfirmDelete = false;
}
if (mat != null)
{
TextAsset ta = EditorGUILayout.ObjectField("TP Import", null, typeof(TextAsset), false) as TextAsset;
if (ta != null)
{
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false);
}
NGUIEditorTools.RegisterUndo("Import Sprites", mAtlas);
NGUIJson.LoadSpriteData(mAtlas, ta);
if (sprite != null)
{
sprite = mAtlas.GetSprite(sprite.name);
}
mAtlas.MarkAsDirty();
}
UIAtlas.Coordinates coords = (UIAtlas.Coordinates)EditorGUILayout.EnumPopup("Coordinates", mAtlas.coordinates);
if (coords != mAtlas.coordinates)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.coordinates = coords;
mConfirmDelete = false;
}
float pixelSize = EditorGUILayout.FloatField("Pixel Size", mAtlas.pixelSize, GUILayout.Width(120f));
if (pixelSize != mAtlas.pixelSize)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.pixelSize = pixelSize;
mConfirmDelete = false;
}
}
}
if (mAtlas.spriteMaterial != null)
{
Color blue = new Color(0f, 0.7f, 1f, 1f);
Color green = new Color(0.4f, 1f, 0f, 1f);
if (mConfirmDelete)
{
if (sprite != null)
{
// Show the confirmation dialog
NGUIEditorTools.DrawSeparator();
GUILayout.Label("Are you sure you want to delete '" + sprite.name + "'?");
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
{
GUI.backgroundColor = Color.green;
if (GUILayout.Button("Cancel"))
{
mConfirmDelete = false;
}
GUI.backgroundColor = Color.red;
if (GUILayout.Button("Delete"))
{
NGUIEditorTools.RegisterUndo("Delete Sprite", mAtlas);
mAtlas.spriteList.Remove(sprite);
mConfirmDelete = false;
}
GUI.backgroundColor = Color.white;
}
GUILayout.EndHorizontal();
}
else
{
mConfirmDelete = false;
}
}
else
{
if (sprite == null && mAtlas.spriteList.Count > 0)
{
string spriteName = NGUISettings.selectedSprite;
if (!string.IsNullOrEmpty(spriteName))
{
sprite = mAtlas.GetSprite(spriteName);
}
if (sprite == null)
{
sprite = mAtlas.spriteList[0];
}
}
if (!mConfirmDelete && sprite != null)
{
NGUIEditorTools.DrawSeparator();
NGUIEditorTools.AdvancedSpriteField(mAtlas, sprite.name, SelectSprite, true);
if (sprite == null)
{
return;
}
Texture2D tex = mAtlas.spriteMaterial.mainTexture as Texture2D;
if (tex != null)
{
Rect inner = sprite.inner;
Rect outer = sprite.outer;
if (mAtlas.coordinates == UIAtlas.Coordinates.Pixels)
{
GUI.backgroundColor = green;
outer = NGUIEditorTools.IntRect("Dimensions", sprite.outer);
Vector4 border = new Vector4(
sprite.inner.xMin - sprite.outer.xMin,
sprite.inner.yMin - sprite.outer.yMin,
sprite.outer.xMax - sprite.inner.xMax,
sprite.outer.yMax - sprite.inner.yMax);
GUI.backgroundColor = blue;
border = NGUIEditorTools.IntPadding("Border", border);
GUI.backgroundColor = Color.white;
inner.xMin = sprite.outer.xMin + border.x;
inner.yMin = sprite.outer.yMin + border.y;
inner.xMax = sprite.outer.xMax - border.z;
inner.yMax = sprite.outer.yMax - border.w;
}
else
{
// Draw the inner and outer rectangle dimensions
GUI.backgroundColor = green;
outer = EditorGUILayout.RectField("Outer Rect", sprite.outer);
GUI.backgroundColor = blue;
inner = EditorGUILayout.RectField("Inner Rect", sprite.inner);
GUI.backgroundColor = Color.white;
}
if (outer.xMax < outer.xMin)
{
outer.xMax = outer.xMin;
}
if (outer.yMax < outer.yMin)
{
outer.yMax = outer.yMin;
}
if (outer != sprite.outer)
{
float x = outer.xMin - sprite.outer.xMin;
float y = outer.yMin - sprite.outer.yMin;
inner.x += x;
inner.y += y;
}
// Sanity checks to ensure that the inner rect is always inside the outer
inner.xMin = Mathf.Clamp(inner.xMin, outer.xMin, outer.xMax);
inner.xMax = Mathf.Clamp(inner.xMax, outer.xMin, outer.xMax);
inner.yMin = Mathf.Clamp(inner.yMin, outer.yMin, outer.yMax);
inner.yMax = Mathf.Clamp(inner.yMax, outer.yMin, outer.yMax);
bool changed = false;
if (sprite.inner != inner || sprite.outer != outer)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
sprite.inner = inner;
sprite.outer = outer;
MarkSpriteAsDirty();
changed = true;
}
EditorGUILayout.Separator();
if (mAtlas.coordinates == UIAtlas.Coordinates.Pixels)
{
int left = Mathf.RoundToInt(sprite.paddingLeft * sprite.outer.width);
int right = Mathf.RoundToInt(sprite.paddingRight * sprite.outer.width);
int top = Mathf.RoundToInt(sprite.paddingTop * sprite.outer.height);
int bottom = Mathf.RoundToInt(sprite.paddingBottom * sprite.outer.height);
NGUIEditorTools.IntVector a = NGUIEditorTools.IntPair("Padding", "Left", "Top", left, top);
NGUIEditorTools.IntVector b = NGUIEditorTools.IntPair(null, "Right", "Bottom", right, bottom);
if (changed || a.x != left || a.y != top || b.x != right || b.y != bottom)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
sprite.paddingLeft = a.x / sprite.outer.width;
sprite.paddingTop = a.y / sprite.outer.height;
sprite.paddingRight = b.x / sprite.outer.width;
sprite.paddingBottom = b.y / sprite.outer.height;
MarkSpriteAsDirty();
}
}
else
{
// Create a button that can make the coordinates pixel-perfect on click
GUILayout.BeginHorizontal();
{
GUILayout.Label("Correction", GUILayout.Width(75f));
Rect corrected0 = outer;
Rect corrected1 = inner;
if (mAtlas.coordinates == UIAtlas.Coordinates.Pixels)
{
corrected0 = NGUIMath.MakePixelPerfect(corrected0);
corrected1 = NGUIMath.MakePixelPerfect(corrected1);
}
else
{
corrected0 = NGUIMath.MakePixelPerfect(corrected0, tex.width, tex.height);
corrected1 = NGUIMath.MakePixelPerfect(corrected1, tex.width, tex.height);
}
if (corrected0 == sprite.outer && corrected1 == sprite.inner)
{
GUI.color = Color.grey;
GUILayout.Button("Make Pixel-Perfect");
GUI.color = Color.white;
}
else if (GUILayout.Button("Make Pixel-Perfect"))
{
outer = corrected0;
inner = corrected1;
GUI.changed = true;
}
}
GUILayout.EndHorizontal();
}
}
// This functionality is no longer used. It became obsolete when the Atlas Maker was added.
/*NGUIEditorTools.DrawSeparator();
*
* GUILayout.BeginHorizontal();
* {
* EditorGUILayout.PrefixLabel("Add/Delete");
*
* if (GUILayout.Button("Clone Sprite"))
* {
* NGUIEditorTools.RegisterUndo("Add Sprite", mAtlas);
* UIAtlas.Sprite newSprite = new UIAtlas.Sprite();
*
* if (sprite != null)
* {
* newSprite.name = "Copy of " + sprite.name;
* newSprite.outer = sprite.outer;
* newSprite.inner = sprite.inner;
* }
* else
* {
* newSprite.name = "New Sprite";
* }
*
* mAtlas.spriteList.Add(newSprite);
* sprite = newSprite;
* }
*
* // Show the delete button
* GUI.backgroundColor = Color.red;
*
* if (sprite != null && GUILayout.Button("Delete", GUILayout.Width(55f)))
* {
* mConfirmDelete = true;
* }
* GUI.backgroundColor = Color.white;
* }
* GUILayout.EndHorizontal();*/
if (NGUIEditorTools.previousSelection != null)
{
NGUIEditorTools.DrawSeparator();
GUI.backgroundColor = Color.green;
if (GUILayout.Button("<< Return to " + NGUIEditorTools.previousSelection.name))
{
NGUIEditorTools.SelectPrevious();
}
GUI.backgroundColor = Color.white;
}
}
}
}
}
/// <summary>
/// Draw the UI for this tool.
/// </summary>
void OnGUI()
{
string prefabPath = "";
string matPath = "";
if (NGUISettings.font != null && NGUISettings.font.name == NGUISettings.fontName)
{
prefabPath = AssetDatabase.GetAssetPath(NGUISettings.font.gameObject.GetInstanceID());
if (NGUISettings.font.material != null)
{
matPath = AssetDatabase.GetAssetPath(NGUISettings.font.material.GetInstanceID());
}
}
// Assume default values if needed
if (string.IsNullOrEmpty(NGUISettings.fontName))
{
NGUISettings.fontName = "New Font";
}
if (string.IsNullOrEmpty(prefabPath))
{
prefabPath = NGUIEditorTools.GetSelectionFolder() + NGUISettings.fontName + ".prefab";
}
if (string.IsNullOrEmpty(matPath))
{
matPath = NGUIEditorTools.GetSelectionFolder() + NGUISettings.fontName + ".mat";
}
EditorGUIUtility.LookLikeControls(80f, 80f);
NGUIEditorTools.DrawHeader("Input");
GUILayout.BeginHorizontal();
mType = (FontType)EditorGUILayout.EnumPopup("Type", mType);
GUILayout.Space(18f);
GUILayout.EndHorizontal();
int create = 0;
if (mType == FontType.Dynamic)
{
NGUISettings.dynamicFont = EditorGUILayout.ObjectField("Font TTF", NGUISettings.dynamicFont, typeof(Font), false) as Font;
GUILayout.BeginHorizontal();
NGUISettings.dynamicFontSize = EditorGUILayout.IntField("Font Size", NGUISettings.dynamicFontSize, GUILayout.Width(120f));
NGUISettings.dynamicFontStyle = (FontStyle)EditorGUILayout.EnumPopup(NGUISettings.dynamicFontStyle);
GUILayout.Space(18f);
GUILayout.EndHorizontal();
if (NGUISettings.dynamicFont != null)
{
NGUIEditorTools.DrawHeader("Output");
GUILayout.BeginHorizontal();
GUILayout.Label("Font Name", GUILayout.Width(76f));
GUI.backgroundColor = Color.white;
NGUISettings.fontName = GUILayout.TextField(NGUISettings.fontName);
GUILayout.EndHorizontal();
}
NGUIEditorTools.DrawSeparator();
#if UNITY_3_5
EditorGUILayout.HelpBox("Dynamic fonts require Unity 4.0 or higher.", MessageType.Error);
#else
// Helpful info
if (NGUISettings.dynamicFont == null)
{
EditorGUILayout.HelpBox("Dynamic font creation happens right in Unity. Simply specify the TrueType font to be used as source.", MessageType.Info);
}
EditorGUILayout.HelpBox("Please note that dynamic fonts can't be made a part of an atlas, and they will always be drawn in a separate draw call. You WILL need to adjust transform position's Z rather than depth!", MessageType.Warning);
if (NGUISettings.dynamicFont != null)
{
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUI.backgroundColor = Color.green;
GameObject go = AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject)) as GameObject;
if (go != null)
{
if (go.GetComponent <UIFont>() != null)
{
GUI.backgroundColor = Color.red;
if (GUILayout.Button("Replace the Font", GUILayout.Width(140f)))
{
create = 1;
}
}
else
{
GUI.backgroundColor = Color.grey;
GUILayout.Button("Rename Your Font", GUILayout.Width(140f));
}
}
else
{
GUI.backgroundColor = Color.green;
if (GUILayout.Button("Create the Font", GUILayout.Width(140f)))
{
create = 1;
}
}
GUI.backgroundColor = Color.white;
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
#endif
}
else
{
NGUISettings.fontData = EditorGUILayout.ObjectField("Font Data", NGUISettings.fontData, typeof(TextAsset), false) as TextAsset;
NGUISettings.fontTexture = EditorGUILayout.ObjectField("Texture", NGUISettings.fontTexture, typeof(Texture2D), false) as Texture2D;
// Draw the atlas selection only if we have the font data and texture specified, just to make it easier
if (NGUISettings.fontData != null && NGUISettings.fontTexture != null)
{
NGUIEditorTools.DrawHeader("Output");
GUILayout.BeginHorizontal();
GUILayout.Label("Font Name", GUILayout.Width(76f));
GUI.backgroundColor = Color.white;
NGUISettings.fontName = GUILayout.TextField(NGUISettings.fontName);
GUILayout.EndHorizontal();
ComponentSelector.Draw <UIFont>("Select", NGUISettings.font, OnSelectFont);
ComponentSelector.Draw <UIAtlas>(NGUISettings.atlas, OnSelectAtlas);
}
NGUIEditorTools.DrawSeparator();
// Helpful info
if (NGUISettings.fontData == null)
{
EditorGUILayout.HelpBox("The bitmap font creation mostly takes place outside of Unity. You can use BMFont on" +
"Windows or your choice of Glyph Designer or the less expensive bmGlyph on the Mac.\n\n" +
"Either of these tools will create a FNT file for you that you will drag & drop into the field above.", MessageType.Info);
}
else if (NGUISettings.fontTexture == null)
{
EditorGUILayout.HelpBox("When exporting your font, you should get two files: the TXT, and the texture. Only one texture can be used per font.", MessageType.Info);
}
else if (NGUISettings.atlas == null)
{
EditorGUILayout.HelpBox("You can create a font that doesn't use a texture atlas. This will mean that the text " +
"labels using this font will generate an extra draw call, and will need to be sorted by " +
"adjusting the Z instead of the Depth.\n\nIf you do specify an atlas, the font's texture will be added to it automatically.", MessageType.Info);
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUI.backgroundColor = Color.red;
if (GUILayout.Button("Create a Font without an Atlas", GUILayout.Width(200f)))
{
create = 2;
}
GUI.backgroundColor = Color.white;
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
else
{
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GameObject go = AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject)) as GameObject;
if (go != null)
{
if (go.GetComponent <UIFont>() != null)
{
GUI.backgroundColor = Color.red;
if (GUILayout.Button("Replace the Font", GUILayout.Width(140f)))
{
create = 3;
}
}
else
{
GUI.backgroundColor = Color.grey;
GUILayout.Button("Rename Your Font", GUILayout.Width(140f));
}
}
else
{
GUI.backgroundColor = Color.green;
if (GUILayout.Button("Create the Font", GUILayout.Width(140f)))
{
create = 3;
}
}
GUI.backgroundColor = Color.white;
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
}
if (create != 0)
{
GameObject go = AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject)) as GameObject;
if (go == null || EditorUtility.DisplayDialog("Are you sure?", "Are you sure you want to replace the contents of the " +
NGUISettings.fontName + " font with the currently selected values? This action can't be undone.", "Yes", "No"))
{
// Try to load the material
Material mat = null;
// Non-atlased font
if (create == 2)
{
mat = AssetDatabase.LoadAssetAtPath(matPath, typeof(Material)) as Material;
// If the material doesn't exist, create it
if (mat == null)
{
Shader shader = Shader.Find("Unlit/Transparent Colored");
mat = new Material(shader);
// Save the material
AssetDatabase.CreateAsset(mat, matPath);
AssetDatabase.Refresh();
// Load the material so it's usable
mat = AssetDatabase.LoadAssetAtPath(matPath, typeof(Material)) as Material;
}
mat.mainTexture = NGUISettings.fontTexture;
}
// Font doesn't exist yet
if (go == null || go.GetComponent <UIFont>() == null)
{
// Create a new prefab for the atlas
Object prefab = CreateEmptyPrefab(prefabPath);
// Create a new game object for the font
go = new GameObject(NGUISettings.fontName);
NGUISettings.font = go.AddComponent <UIFont>();
CreateFont(NGUISettings.font, create, mat);
// Update the prefab
ReplacePrefab(go, prefab);
DestroyImmediate(go);
AssetDatabase.Refresh();
// Select the atlas
go = AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject)) as GameObject;
NGUISettings.font = go.GetComponent <UIFont>();
}
else
{
NGUISettings.font = go.GetComponent <UIFont>();
CreateFont(NGUISettings.font, create, mat);
}
MarkAsChanged();
}
}
}
/// <summary>
/// Draw the inspector widget.
/// </summary>
public override void OnInspectorGUI()
{
UIPanel panel = target as UIPanel;
BetterList <UIDrawCall> drawcalls = panel.drawCalls;
EditorGUIUtility.LookLikeControls(80f);
//NGUIEditorTools.DrawSeparator();
EditorGUILayout.Space();
float alpha = EditorGUILayout.Slider("Alpha", panel.alpha, 0f, 1f);
if (alpha != panel.alpha)
{
NGUIEditorTools.RegisterUndo("Panel Alpha", panel);
panel.alpha = alpha;
}
if (panel.showInPanelTool != EditorGUILayout.Toggle("Panel Tool", panel.showInPanelTool))
{
panel.showInPanelTool = !panel.showInPanelTool;
EditorUtility.SetDirty(panel);
EditorWindow.FocusWindowIfItsOpen <UIPanelTool>();
}
GUILayout.BeginHorizontal();
bool norms = EditorGUILayout.Toggle("Normals", panel.generateNormals, GUILayout.Width(100f));
GUILayout.Label("Needed for lit shaders");
GUILayout.EndHorizontal();
if (panel.generateNormals != norms)
{
panel.generateNormals = norms;
panel.UpdateDrawcalls();
EditorUtility.SetDirty(panel);
}
GUILayout.BeginHorizontal();
bool depth = EditorGUILayout.Toggle("Depth Pass", panel.depthPass, GUILayout.Width(100f));
GUILayout.Label("Doubles draw calls, saves fillrate");
GUILayout.EndHorizontal();
if (panel.depthPass != depth)
{
panel.depthPass = depth;
panel.UpdateDrawcalls();
EditorUtility.SetDirty(panel);
}
if (depth)
{
UICamera cam = UICamera.FindCameraForLayer(panel.gameObject.layer);
if (cam == null || cam.GetComponent <Camera>().orthographic)
{
EditorGUILayout.HelpBox("Please note that depth pass will only save fillrate when used with 3D UIs, and only UIs drawn by the game camera. If you are using a separate camera for the UI, you will not see any benefit!", MessageType.Warning);
}
}
GUILayout.BeginHorizontal();
bool stat = EditorGUILayout.Toggle("Static", panel.widgetsAreStatic, GUILayout.Width(100f));
GUILayout.Label("Check if widgets won't move");
GUILayout.EndHorizontal();
if (panel.widgetsAreStatic != stat)
{
panel.widgetsAreStatic = stat;
panel.UpdateDrawcalls();
EditorUtility.SetDirty(panel);
}
EditorGUILayout.LabelField("Widgets", panel.widgets.size.ToString());
EditorGUILayout.LabelField("Draw Calls", drawcalls.size.ToString());
UIPanel.DebugInfo di = (UIPanel.DebugInfo)EditorGUILayout.EnumPopup("Debug Info", panel.debugInfo);
if (panel.debugInfo != di)
{
panel.debugInfo = di;
EditorUtility.SetDirty(panel);
}
UIDrawCall.Clipping clipping = (UIDrawCall.Clipping)EditorGUILayout.EnumPopup("Clipping", panel.clipping);
if (panel.clipping != clipping)
{
panel.clipping = clipping;
EditorUtility.SetDirty(panel);
}
if (panel.clipping != UIDrawCall.Clipping.None)
{
Vector4 range = panel.clipRange;
GUILayout.BeginHorizontal();
GUILayout.Space(80f);
Vector2 pos = EditorGUILayout.Vector2Field("Center", new Vector2(range.x, range.y));
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Space(80f);
Vector2 size = EditorGUILayout.Vector2Field("Size", new Vector2(range.z, range.w));
GUILayout.EndHorizontal();
if (size.x < 0f)
{
size.x = 0f;
}
if (size.y < 0f)
{
size.y = 0f;
}
range.x = pos.x;
range.y = pos.y;
range.z = size.x;
range.w = size.y;
if (panel.clipRange != range)
{
NGUIEditorTools.RegisterUndo("Clipping Change", panel);
panel.clipRange = range;
EditorUtility.SetDirty(panel);
}
if (panel.clipping == UIDrawCall.Clipping.SoftClip)
{
GUILayout.BeginHorizontal();
GUILayout.Space(80f);
Vector2 soft = EditorGUILayout.Vector2Field("Softness", panel.clipSoftness);
GUILayout.EndHorizontal();
if (soft.x < 1f)
{
soft.x = 1f;
}
if (soft.y < 1f)
{
soft.y = 1f;
}
if (panel.clipSoftness != soft)
{
NGUIEditorTools.RegisterUndo("Clipping Change", panel);
panel.clipSoftness = soft;
EditorUtility.SetDirty(panel);
}
}
#if !UNITY_3_5 && !UNITY_4_0 && (UNITY_ANDROID || UNITY_IPHONE)
if (PlayerSettings.targetGlesGraphics == TargetGlesGraphics.OpenGLES_1_x)
{
EditorGUILayout.HelpBox("Clipping requires shader support!\n\nOpen File -> Build Settings -> Player Settings -> Other Settings, then set:\n\n- Graphics Level: OpenGL ES 2.0.", MessageType.Error);
}
#endif
}
if (clipping == UIDrawCall.Clipping.HardClip)
{
EditorGUILayout.HelpBox("Hard clipping has been removed due to major performance issues on certain Android devices. Alpha clipping will be used instead.", MessageType.Warning);
}
if (clipping != UIDrawCall.Clipping.None && !NGUIEditorTools.IsUniform(panel.transform.lossyScale))
{
EditorGUILayout.HelpBox("Clipped panels must have a uniform scale, or clipping won't work properly!", MessageType.Error);
if (GUILayout.Button("Auto-fix"))
{
NGUIEditorTools.FixUniform(panel.gameObject);
}
}
foreach (UIDrawCall dc in drawcalls)
{
NGUIEditorTools.DrawSeparator();
EditorGUILayout.ObjectField("Material", dc.material, typeof(Material), false);
EditorGUILayout.LabelField("Triangles", dc.triangles.ToString());
if (clipping != UIDrawCall.Clipping.None && !dc.isClipped)
{
EditorGUILayout.HelpBox("You must switch this material's shader to Unlit/Transparent Colored or Unlit/Premultiplied Colored in order for clipping to work.",
MessageType.Warning);
}
}
}
public override void OnInspectorGUI()
{
EditorGUIUtility.LookLikeControls(80f);
UISlider slider = target as UISlider;
NGUIEditorTools.DrawSeparator();
float sliderValue = EditorGUILayout.Slider("Value", slider.sliderValue, 0f, 1f);
if (slider.sliderValue != sliderValue)
{
NGUIEditorTools.RegisterUndo("Slider Change", slider);
slider.sliderValue = sliderValue;
UnityEditor.EditorUtility.SetDirty(slider);
}
int steps = EditorGUILayout.IntSlider("Steps", slider.numberOfSteps, 0, 11);
if (slider.numberOfSteps != steps)
{
NGUIEditorTools.RegisterUndo("Slider Change", slider);
slider.numberOfSteps = steps;
slider.ForceUpdate();
UnityEditor.EditorUtility.SetDirty(slider);
}
NGUIEditorTools.DrawSeparator();
Transform fg = EditorGUILayout.ObjectField("Foreground", slider.foreground, typeof(Transform), true) as Transform;
Transform tb = EditorGUILayout.ObjectField("Thumb", slider.thumb, typeof(Transform), true) as Transform;
UISlider.Direction dir = (UISlider.Direction)EditorGUILayout.EnumPopup("Direction", slider.direction);
// If we're using a sprite for the foreground, ensure it's using a proper pivot.
ValidatePivot(fg, "Foreground sprite", dir);
NGUIEditorTools.DrawSeparator();
GameObject er = EditorGUILayout.ObjectField("Event Recv.", slider.eventReceiver, typeof(GameObject), true) as GameObject;
GUILayout.BeginHorizontal();
string fn = EditorGUILayout.TextField("Function", slider.functionName);
GUILayout.Space(18f);
GUILayout.EndHorizontal();
if (slider.foreground != fg ||
slider.thumb != tb ||
slider.direction != dir ||
slider.eventReceiver != er ||
slider.functionName != fn)
{
NGUIEditorTools.RegisterUndo("Slider Change", slider);
slider.foreground = fg;
slider.thumb = tb;
slider.direction = dir;
slider.eventReceiver = er;
slider.functionName = fn;
if (slider.thumb != null)
{
slider.thumb.localPosition = Vector3.zero;
slider.sliderValue = -1f;
slider.sliderValue = sliderValue;
}
else
{
slider.ForceUpdate();
}
UnityEditor.EditorUtility.SetDirty(slider);
}
}
/// <summary>
/// Draw the custom wizard.
/// </summary>
void OnGUI()
{
List <UIPanel> panels = GetListOfPanels();
if (panels != null && panels.Count > 0)
{
UIPanel selectedPanel = NGUITools.FindInParents <UIPanel>(Selection.activeGameObject);
// First, collect a list of panels with their associated widgets
List <Entry> entries = new List <Entry>();
Entry selectedEntry = null;
bool allEnabled = true;
foreach (UIPanel panel in panels)
{
Entry ent = new Entry();
ent.panel = panel;
ent.widgets = GetWidgets(panel);
ent.isEnabled = panel.enabled && NGUITools.GetActive(panel.gameObject);
ent.widgetsEnabled = ent.isEnabled;
if (ent.widgetsEnabled)
{
foreach (UIWidget w in ent.widgets)
{
if (!NGUITools.GetActive(w.gameObject))
{
allEnabled = false;
ent.widgetsEnabled = false;
break;
}
}
}
else
{
allEnabled = false;
}
entries.Add(ent);
}
// Sort the list by depth
entries.Sort(Compare);
mScroll = GUILayout.BeginScrollView(mScroll);
NGUIEditorTools.SetLabelWidth(80f);
bool showAll = DrawRow(null, null, allEnabled);
NGUIEditorTools.DrawSeparator();
foreach (Entry ent in entries)
{
if (DrawRow(ent, selectedPanel, ent.widgetsEnabled))
{
selectedEntry = ent;
}
}
GUILayout.EndScrollView();
if (showAll)
{
foreach (Entry ent in entries)
{
NGUITools.SetActive(ent.panel.gameObject, !allEnabled);
}
}
else if (selectedEntry != null)
{
NGUITools.SetActive(selectedEntry.panel.gameObject, !selectedEntry.widgetsEnabled);
}
}
else
{
GUILayout.Label("No UI Panels found in the scene");
}
}
/// <summary>
/// Draw the custom wizard.
/// </summary>
void OnGUI()
{
EditorGUIUtility.LookLikeControls(80f);
GUILayout.BeginHorizontal();
GUILayout.Label("当前版本号：", GUILayout.Width(120f));
currentVersion = GUILayout.TextField(currentVersion);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("目标版本号：", GUILayout.Width(120f));
newVersion = GUILayout.TextField(newVersion);
GUILayout.EndHorizontal();
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
GUILayout.Label("选择打包资源：", GUILayout.Width(120f));
bool tempAll = selectAll;
selectAll = GUILayout.Toggle(tempAll, "全选");
GUILayout.EndHorizontal();
if (ExportScenesManager.BuildResourcesInfoList != null)
{
foreach (var item in ExportScenesManager.BuildResourcesInfoList)
{
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
bool temp = item.check;
bool hasChanged = false;
if (selectAll != tempAll)
{
item.check = selectAll;
}
item.check = GUILayout.Toggle(item.check, item.name);
GUILayout.Label(item.type, GUILayout.Width(100f));
foreach (var ex in item.extentions)
{
GUILayout.Label(ex, GUILayout.Width(100f));
}
hasChanged = temp != item.check;
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
foreach (var folder in item.folders)
{
if (hasChanged)
{
folder.check = item.check;
}
folder.check = GUILayout.Toggle(folder.check, folder.path);
}
GUILayout.EndHorizontal();
}
}
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
GUILayout.Label("选择拷贝资源：", GUILayout.Width(120f));
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
if (ExportScenesManager.CopyResourcesInfoList != null)
{
foreach (var item in ExportScenesManager.CopyResourcesInfoList)
{
item.check = GUILayout.Toggle(item.check, item.sourcePath);
}
}
GUILayout.EndHorizontal();
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
bool create = GUILayout.Button("确定", GUILayout.Width(120f));
GUILayout.EndHorizontal();
if (create)
{
Export();
}
}
