public static void InspectorGUI(BuildrEditMode editMode, BuildrData data)
{
BuildrDetail[] details = data.details.ToArray();
int numberOfDetails = details.Length;
selectedDetail = Mathf.Clamp(selectedDetail, 0, numberOfDetails - 1);
if (numberOfDetails == 0)
{
EditorGUILayout.HelpBox("There are no details to show", MessageType.Info);
if (GUILayout.Button("Add New"))
{
data.details.Add(new BuildrDetail("new detail " + numberOfDetails));
numberOfDetails++;
selectedDetail = numberOfDetails - 1;
}
return;
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Detail", GUILayout.Width(75));
string[] detailNames = new string[numberOfDetails];
for (int t = 0; t < numberOfDetails; t++)
{
detailNames[t] = details[t].name;
}
selectedDetail = EditorGUILayout.Popup(selectedDetail, detailNames);
EditorGUILayout.EndHorizontal();
BuildrDetail bDetail = details[selectedDetail];
EditorGUILayout.BeginHorizontal();
EditorGUILayout.Space();
if (GUILayout.Button("Add New", GUILayout.Width(81)))
{
data.details.Add(new BuildrDetail("new detail " + numberOfDetails));
numberOfDetails++;
selectedDetail = numberOfDetails - 1;
}
if (GUILayout.Button("Duplicate", GUILayout.Width(90)))
{
data.details.Add(bDetail.Duplicate());
numberOfDetails++;
selectedDetail = numberOfDetails - 1;
}
if (GUILayout.Button("Delete", GUILayout.Width(71)))
{
if (EditorUtility.DisplayDialog("Deleting Building Detail Entry", "Are you sure you want to delete this detail?", "Delete", "Cancel"))
{
data.details.Remove(bDetail);
selectedDetail = 0;
GUI.changed = true;
return;
}
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
details = data.details.ToArray();
detailNames = new string[numberOfDetails];
for (int t = 0; t < numberOfDetails; t++)
{
detailNames[t] = details[t].name;
}
bDetail = details[selectedDetail];//reassign
EditorGUILayout.BeginHorizontal();
EditorGUILayout.BeginVertical();
bDetail.name = EditorGUILayout.TextField("Name", bDetail.name);
bDetail.mesh = (Mesh)EditorGUILayout.ObjectField("Mesh", bDetail.mesh, typeof(Mesh), false);
EditorGUIUtility.LookLikeControls();
bDetail.material.mainTexture = (Texture)EditorGUILayout.ObjectField("Texture", bDetail.material.mainTexture, typeof(Texture), false, GUILayout.Height(140));
if (bDetail.material.mainTexture != null)
{
string texturePath = AssetDatabase.GetAssetPath(bDetail.material.mainTexture);
TextureImporter textureImporter = (TextureImporter)AssetImporter.GetAtPath(texturePath);
if (!textureImporter.isReadable)
{
EditorGUILayout.HelpBox("The texture you have selected is not readable." +
"\nPlease select the readable checkbox under advanced texture settings." +
"\nOr move this texture to the BuildR texture folder and reimport.",
MessageType.Error);
}
}
BuildrPlan plan = data.plan;
int numberOfVolumes = plan.numberOfVolumes;
int numberOfFaces = 0;
List <int> faceSeletionsList = new List <int>();
List <string> faceSeletionsStringList = new List <string>();
if (bDetail.type == BuildrDetail.Types.Facade)
{
for (int s = 0; s < numberOfVolumes; s++)
{
int numberOfPoints = plan.volumes[s].Count;
numberOfFaces += numberOfPoints;
for (int p = 0; p < numberOfPoints; p++)
{
int index = faceSeletionsList.Count;
faceSeletionsStringList.Add("facade " + index);
faceSeletionsList.Add(index);
}
}
}
else
{
bDetail.face = Mathf.Clamp(0, numberOfVolumes - 1, bDetail.face);
for (int s = 0; s < numberOfVolumes; s++)
{
int index = faceSeletionsList.Count;
faceSeletionsStringList.Add("roof " + index);
faceSeletionsList.Add(index);
}
}
if (!clickPlace)
{
if (GUILayout.Button("Place Detail with Mouse"))
{
clickPlace = true;
}
}
else
{
if (GUILayout.Button("Cancel Place Detail"))
{
clickPlace = false;
}
}
BuildrDetail.Types bDetailtype = (BuildrDetail.Types)EditorGUILayout.EnumPopup("Face Type", bDetail.type);
if (bDetailtype != bDetail.type)
{
bDetail.type = bDetailtype;
}
int[] faceSelections = faceSeletionsList.ToArray();
string[] faceSelectionString = faceSeletionsStringList.ToArray();
int bDetailface = EditorGUILayout.IntPopup("Selected Face", bDetail.face, faceSelectionString, faceSelections);
if (bDetailface != bDetail.face)
{
bDetail.face = bDetailface;
}
Vector2 bDetailfaceUv = EditorGUILayout.Vector2Field("Face UV", bDetail.faceUv);
if (bDetailfaceUv != bDetail.faceUv)
{
bDetail.faceUv = bDetailfaceUv;
}
float bDetailfaceHeight = EditorGUILayout.FloatField("Face Height", bDetail.faceHeight);
if (bDetailfaceHeight != bDetail.faceHeight)
{
bDetail.faceHeight = bDetailfaceHeight;
}
Vector3 bDetailuserRotation = EditorGUILayout.Vector3Field("Rotation", bDetail.userRotation);
if (bDetailuserRotation != bDetail.userRotation)
{
bDetail.userRotation = bDetailuserRotation;
}
Vector3 bDetailscale = EditorGUILayout.Vector3Field("Object Scale", bDetail.scale);
if (bDetailscale != bDetail.scale)
{
bDetail.scale = bDetailscale;
}
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical(GUILayout.Width(120));
if (bDetail.mesh != null)
{
Texture2D previewMeshImage = AssetPreview.GetAssetPreview(bDetail.mesh);
GUILayout.Label(previewMeshImage);
}
else
{
Texture2D previewMeshImage = new Texture2D(118, 118);
GUILayout.Label(previewMeshImage);
GUILayout.Label("No Mesh Selected");
}
if (bDetail.material.mainTexture != null)
{
Texture previewMeshImage = bDetail.material.mainTexture;
GUILayout.Label(previewMeshImage, GUILayout.Width(128), GUILayout.Height(128));
}
else
{
Texture2D previewMeshImage = new Texture2D(118, 118);
GUILayout.Label(previewMeshImage);
GUILayout.Label("No Texture Selected");
}
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
}
public override void OnInspectorGUI(NavGraph target)
{
GridGraph graph = target as GridGraph;
//GUILayout.BeginHorizontal ();
//GUILayout.BeginVertical ();
Rect lockRect;
GUIStyle lockStyle = AstarPathEditor.astarSkin.FindStyle("GridSizeLock");
if (lockStyle == null)
{
lockStyle = new GUIStyle();
}
#if !UNITY_LE_4_3 || true
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
int newWidth = EditorGUILayout.IntField(new GUIContent("Width (nodes)", "Width of the graph in nodes"), graph.width);
int newDepth = EditorGUILayout.IntField(new GUIContent("Depth (nodes)", "Depth (or height you might also call it) of the graph in nodes"), graph.depth);
GUILayout.EndVertical();
lockRect = GUILayoutUtility.GetRect(lockStyle.fixedWidth, lockStyle.fixedHeight);
// Add a small offset to make it better centred around the controls
lockRect.y += 3;
GUILayout.EndHorizontal();
// All the layouts mess up the margin to the next control, so add it manually
GUILayout.Space(2);
#elif UNITY_4
Rect tmpLockRect;
int newWidth = IntField(new GUIContent("Width (nodes)", "Width of the graph in nodes"), graph.width, 100, 0, out lockRect, out sizeSelected1);
int newDepth = IntField(new GUIContent("Depth (nodes)", "Depth (or height you might also call it) of the graph in nodes"), graph.depth, 100, 0, out tmpLockRect, out sizeSelected2);
#else
Rect tmpLockRect;
int newWidth = IntField(new GUIContent("Width (nodes)", "Width of the graph in nodes"), graph.width, 50, 0, out lockRect, out sizeSelected1);
int newDepth = IntField(new GUIContent("Depth (nodes)", "Depth (or height you might also call it) of the graph in nodes"), graph.depth, 50, 0, out tmpLockRect, out sizeSelected2);
#endif
lockRect.width = lockStyle.fixedWidth;
lockRect.height = lockStyle.fixedHeight;
lockRect.x += lockStyle.margin.left;
lockRect.y += lockStyle.margin.top;
locked = GUI.Toggle(lockRect, locked, new GUIContent("", "If the width and depth values are locked, changing the node size will scale the grid which keeping the number of nodes consistent instead of keeping the size the same and changing the number of nodes in the graph"), lockStyle);
//GUILayout.EndHorizontal ();
if (newWidth != graph.width || newDepth != graph.depth)
{
SnapSizeToNodes(newWidth, newDepth, graph);
}
GUI.SetNextControlName("NodeSize");
newNodeSize = EditorGUILayout.FloatField(new GUIContent("Node size", "The size of a single node. The size is the side of the node square in world units"), graph.nodeSize);
newNodeSize = newNodeSize <= 0.01F ? 0.01F : newNodeSize;
float prevRatio = graph.aspectRatio;
graph.aspectRatio = EditorGUILayout.FloatField(new GUIContent("Aspect Ratio", "Scaling of the nodes width/depth ratio. Good for isometric games"), graph.aspectRatio);
graph.isometricAngle = EditorGUILayout.FloatField(new GUIContent("Isometric Angle", "For an isometric 2D game, you can use this parameter to scale the graph correctly."), graph.isometricAngle);
if (graph.nodeSize != newNodeSize || prevRatio != graph.aspectRatio)
{
if (!locked)
{
graph.nodeSize = newNodeSize;
Matrix4x4 oldMatrix = graph.matrix;
graph.GenerateMatrix();
if (graph.matrix != oldMatrix)
{
//Rescann the graphs
//AstarPath.active.AutoScan ();
GUI.changed = true;
}
}
else
{
float delta = newNodeSize / graph.nodeSize;
graph.nodeSize = newNodeSize;
graph.unclampedSize = new Vector2(newWidth * graph.nodeSize, newDepth * graph.nodeSize);
Vector3 newCenter = graph.matrix.MultiplyPoint3x4(new Vector3((newWidth / 2F) * delta, 0, (newDepth / 2F) * delta));
graph.center = newCenter;
graph.GenerateMatrix();
//Make sure the width & depths stay the same
graph.width = newWidth;
graph.depth = newDepth;
AutoScan();
}
}
Vector3 pivotPoint;
Vector3 diff;
#if UNITY_LE_4_3
EditorGUIUtility.LookLikeControls();
#endif
#if !UNITY_4
EditorGUILayoutx.BeginIndent();
#else
GUILayout.BeginHorizontal();
#endif
switch (pivot)
{
case GridPivot.Center:
graph.center = RoundVector3(graph.center);
graph.center = EditorGUILayout.Vector3Field("Center", graph.center);
break;
case GridPivot.TopLeft:
pivotPoint = graph.matrix.MultiplyPoint3x4(new Vector3(0, 0, graph.depth));
pivotPoint = RoundVector3(pivotPoint);
diff = pivotPoint - graph.center;
pivotPoint = EditorGUILayout.Vector3Field("Top-Left", pivotPoint);
graph.center = pivotPoint - diff;
break;
case GridPivot.TopRight:
pivotPoint = graph.matrix.MultiplyPoint3x4(new Vector3(graph.width, 0, graph.depth));
pivotPoint = RoundVector3(pivotPoint);
diff = pivotPoint - graph.center;
pivotPoint = EditorGUILayout.Vector3Field("Top-Right", pivotPoint);
graph.center = pivotPoint - diff;
break;
case GridPivot.BottomLeft:
pivotPoint = graph.matrix.MultiplyPoint3x4(new Vector3(0, 0, 0));
pivotPoint = RoundVector3(pivotPoint);
diff = pivotPoint - graph.center;
pivotPoint = EditorGUILayout.Vector3Field("Bottom-Left", pivotPoint);
graph.center = pivotPoint - diff;
break;
case GridPivot.BottomRight:
pivotPoint = graph.matrix.MultiplyPoint3x4(new Vector3(graph.width, 0, 0));
pivotPoint = RoundVector3(pivotPoint);
diff = pivotPoint - graph.center;
pivotPoint = EditorGUILayout.Vector3Field("Bottom-Right", pivotPoint);
graph.center = pivotPoint - diff;
break;
}
graph.GenerateMatrix();
pivot = PivotPointSelector(pivot);
#if !UNITY_4
EditorGUILayoutx.EndIndent();
EditorGUILayoutx.BeginIndent();
#else
GUILayout.EndHorizontal();
#endif
graph.rotation = EditorGUILayout.Vector3Field("Rotation", graph.rotation);
#if UNITY_LE_4_3
//Add some space to make the Rotation and postion fields be better aligned (instead of the pivot point selector)
//GUILayout.Space (19+7);
#endif
//GUILayout.EndHorizontal ();
#if !UNITY_4
EditorGUILayoutx.EndIndent();
#endif
#if UNITY_LE_4_3
EditorGUIUtility.LookLikeInspector();
#endif
if (GUILayout.Button(new GUIContent("Snap Size", "Snap the size to exactly fit nodes"), GUILayout.MaxWidth(100), GUILayout.MaxHeight(16)))
{
SnapSizeToNodes(newWidth, newDepth, graph);
}
Separator();
graph.cutCorners = EditorGUILayout.Toggle(new GUIContent("Cut Corners", "Enables or disables cutting corners. See docs for image example"), graph.cutCorners);
if (!graph.cutCorners && graph.useJumpPointSearch)
{
EditorGUILayout.HelpBox("Jump Point Search only works if 'Cut Corners' is enabled.", MessageType.Error);
}
graph.neighbours = (NumNeighbours)EditorGUILayout.EnumPopup(new GUIContent("Connections", "Sets how many connections a node should have to it's neighbour nodes."), graph.neighbours);
if (graph.neighbours != NumNeighbours.Eight && graph.useJumpPointSearch)
{
EditorGUILayout.HelpBox("Jump Point Search only works for 8 neighbours.", MessageType.Error);
}
graph.maxClimb = EditorGUILayout.FloatField(new GUIContent("Max Climb", "How high, relative to the graph, should a climbable level be. A zero (0) indicates infinity"), graph.maxClimb);
if (graph.maxClimb < 0)
{
graph.maxClimb = 0;
}
EditorGUI.indentLevel++;
graph.maxClimbAxis = EditorGUILayout.IntPopup(new GUIContent("Climb Axis", "Determines which axis the above setting should test on"), graph.maxClimbAxis, new GUIContent[3] {
new GUIContent("X"), new GUIContent("Y"), new GUIContent("Z")
}, new int[3] {
0, 1, 2
});
EditorGUI.indentLevel--;
if (graph.maxClimb > 0 && Mathf.Abs((Quaternion.Euler(graph.rotation) * new Vector3(graph.nodeSize, 0, graph.nodeSize))[graph.maxClimbAxis]) > graph.maxClimb)
{
EditorGUILayout.HelpBox("Nodes are spaced further apart than this in the grid. You might want to increase this value or change the axis", MessageType.Warning);
}
//GUILayout.EndHorizontal ();
graph.maxSlope = EditorGUILayout.Slider(new GUIContent("Max Slope", "Sets the max slope in degrees for a point to be walkable. Only enabled if Height Testing is enabled."), graph.maxSlope, 0, 90F);
graph.erodeIterations = EditorGUILayout.IntField(new GUIContent("Erosion iterations", "Sets how many times the graph should be eroded. This adds extra margin to objects. This will not work when using Graph Updates, so if you can, use the Diameter setting in collision settings instead"), graph.erodeIterations);
graph.erodeIterations = graph.erodeIterations < 0 ? 0 : (graph.erodeIterations > 16 ? 16 : graph.erodeIterations); //Clamp iterations to [0,16]
if (graph.erodeIterations > 0)
{
EditorGUI.indentLevel++;
graph.erosionUseTags = EditorGUILayout.Toggle(new GUIContent("Erosion Uses Tags", "Instead of making nodes unwalkable, " +
"nodes will have their tag set to a value corresponding to their erosion level, " +
"which is a quite good measurement of their distance to the closest wall.\nSee online documentation for more info."),
graph.erosionUseTags);
if (graph.erosionUseTags)
{
EditorGUI.indentLevel++;
graph.erosionFirstTag = EditorGUILayoutx.SingleTagField("First Tag", graph.erosionFirstTag);
EditorGUI.indentLevel--;
}
EditorGUI.indentLevel--;
}
DrawCollisionEditor(graph.collision);
if (graph.collision.use2D)
{
if (Mathf.Abs(Vector3.Dot(Vector3.forward, Quaternion.Euler(graph.rotation) * Vector3.up)) < 0.9f)
{
EditorGUILayout.HelpBox("When using 2D it is recommended to rotate the graph so that it aligns with the 2D plane.", MessageType.Warning);
}
}
Separator();
GUILayout.Label(new GUIContent("Advanced"), EditorStyles.boldLabel);
showExtra = EditorGUILayout.Foldout(showExtra, "Penalty Modifications");
if (showExtra)
{
EditorGUI.indentLevel += 2;
graph.penaltyAngle = ToggleGroup(new GUIContent("Angle Penalty", "Adds a penalty based on the slope of the node"), graph.penaltyAngle);
//bool preGUI = GUI.enabled;
//GUI.enabled = graph.penaltyAngle && GUI.enabled;
if (graph.penaltyAngle)
{
EditorGUI.indentLevel++;
graph.penaltyAngleFactor = EditorGUILayout.FloatField(new GUIContent("Factor", "Scale of the penalty. A negative value should not be used"), graph.penaltyAngleFactor);
graph.penaltyAnglePower = EditorGUILayout.Slider("Power", graph.penaltyAnglePower, 0.1f, 10f);
//GUI.enabled = preGUI;
HelpBox("Applies penalty to nodes based on the angle of the hit surface during the Height Testing\nPenalty applied is: P=(1-cos(angle)^power)*factor.");
EditorGUI.indentLevel--;
}
graph.penaltyPosition = ToggleGroup("Position Penalty", graph.penaltyPosition);
//EditorGUILayout.Toggle ("Position Penalty",graph.penaltyPosition);
//preGUI = GUI.enabled;
//GUI.enabled = graph.penaltyPosition && GUI.enabled;
if (graph.penaltyPosition)
{
EditorGUI.indentLevel++;
graph.penaltyPositionOffset = EditorGUILayout.FloatField("Offset", graph.penaltyPositionOffset);
graph.penaltyPositionFactor = EditorGUILayout.FloatField("Factor", graph.penaltyPositionFactor);
HelpBox("Applies penalty to nodes based on their Y coordinate\nSampled in Int3 space, i.e it is multiplied with Int3.Precision first (" + Int3.Precision + ")\n" +
"Be very careful when using negative values since a negative penalty will underflow and instead get really high");
//GUI.enabled = preGUI;
EditorGUI.indentLevel--;
}
if (textureVisible)
{
DrawTextureData(graph.textureData, graph);
}
EditorGUI.indentLevel -= 2;
}
graph.useJumpPointSearch = EditorGUILayout.Toggle(new GUIContent("Use Jump Point Search", "Jump Point Search can significantly speed up pathfinding. But only works on uniformly weighted graphs"), graph.useJumpPointSearch);
if (graph.useJumpPointSearch)
{
EditorGUILayout.HelpBox("Jump Point Search assumes that there are no penalties applied to the graph. Tag penalties cannot be used either.", MessageType.Warning);
#if !ASTAR_JPS
EditorGUILayout.HelpBox("JPS needs to be enabled using a compiler directive before it can be used.\n" +
"Enabling this will add ASTAR_JPS to the Scriping Define Symbols field in the Unity Player Settings", MessageType.Warning);
if (GUILayout.Button("Enable Jump Point Search support"))
{
var vals = System.Enum.GetValues(typeof(BuildTargetGroup)) as int[];
for (int i = 0; i < vals.Length; i++)
{
string s = PlayerSettings.GetScriptingDefineSymbolsForGroup((BuildTargetGroup)vals[i]);
if (s != null)
{
s += ";ASTAR_JPS";
PlayerSettings.SetScriptingDefineSymbolsForGroup((BuildTargetGroup)vals[i], s);
}
}
}
#endif
}
else
{
#if ASTAR_JPS
EditorGUILayout.HelpBox("If you are not using JPS in any scene, you can disable it to save memory", MessageType.Info);
if (GUILayout.Button("Disable Jump Point Search support"))
{
var vals = System.Enum.GetValues(typeof(BuildTargetGroup)) as int[];
for (int i = 0; i < vals.Length; i++)
{
string s = PlayerSettings.GetScriptingDefineSymbolsForGroup((BuildTargetGroup)vals[i]);
if (s != null)
{
s = s.Replace("ASTAR_JPS;", "");
s = s.Replace(";ASTAR_JPS", "");
s = s.Replace("ASTAR_JPS", "");
PlayerSettings.SetScriptingDefineSymbolsForGroup((BuildTargetGroup)vals[i], s);
}
}
}
#endif
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public override void OnInspectorGUI()
{
exSprite editSprite = target as exSprite;
inAnimMode = AnimationUtility.InAnimationMode();
#if UNITY_3_4
isPrefab = (EditorUtility.GetPrefabType(target) == PrefabType.Prefab);
#else
isPrefab = (PrefabUtility.GetPrefabType(target) == PrefabType.Prefab);
#endif
// TEMP: not sure this is good {
Event e = Event.current;
if (e.type == EventType.MouseDown && e.button == 0 && e.clickCount == 1)
{
if (isPrefab)
{
Undo.RegisterUndo(editPlane, "editPlane");
}
else
{
Undo.RegisterSceneUndo("ex2D.Scene");
}
}
// } TEMP end
EditorGUIUtility.LookLikeInspector();
EditorGUILayout.Space();
++EditorGUI.indentLevel;
if (isPrefab && editPlane.meshFilter && editPlane.meshFilter.sharedMesh)
{
editPlane.meshFilter.sharedMesh = null;
}
// TODO: I do not know how to do it. {
// // ========================================================
// // Script
// // ========================================================
// MonoScript script = (MonoScript)AssetDatabase.LoadAssetAtPath( AssetDatabase.GetAssetPath (target), typeof(MonoScript) );
// script = (MonoScript)EditorGUILayout.ObjectField( "Script", script, typeof(MonoScript) );
// } TODO end
// ========================================================
// trans2d
// ========================================================
GUI.enabled = !inAnimMode;
EditorGUIUtility.LookLikeControls();
Transform2D newTrans2D = (Transform2D)EditorGUILayout.EnumPopup("Transform 2D", trans2d, GUILayout.Width(200), GUILayout.ExpandWidth(false));
EditorGUIUtility.LookLikeInspector();
GUI.enabled = true;
//
if (newTrans2D != trans2d)
{
trans2d = newTrans2D;
exScreenPosition screenPos = editPlane.GetComponent <exScreenPosition>();
if (screenPos != null)
{
Object.DestroyImmediate(screenPos, true);
}
exViewportPosition vpPos = editPlane.GetComponent <exViewportPosition>();
if (vpPos != null)
{
Object.DestroyImmediate(vpPos, true);
}
switch (trans2d)
{
case Transform2D.None:
break;
case Transform2D.Screen:
editPlane.gameObject.AddComponent <exScreenPosition>();
break;
case Transform2D.Viewport:
editPlane.gameObject.AddComponent <exViewportPosition>();
break;
}
}
// ========================================================
// use animation helper
// ========================================================
GUILayout.BeginHorizontal();
GUILayout.Space(15);
GUI.enabled = !inAnimMode;
exAnimationHelper compAnimHelper = editPlane.GetComponent <exAnimationHelper>();
bool hasAnimHelper = compAnimHelper != null;
bool useAnimHelper = GUILayout.Toggle(hasAnimHelper, "Use Animation Helper");
if (useAnimHelper != hasAnimHelper)
{
if (useAnimHelper)
{
AddAnimationHelper();
}
else
{
Object.DestroyImmediate(compAnimHelper, true);
}
GUI.changed = true;
}
GUI.enabled = true;
GUILayout.EndHorizontal();
// ========================================================
// camera type
// ========================================================
GUI.enabled = !inAnimMode;
EditorGUIUtility.LookLikeControls();
if (isPrefab)
{
GUILayout.BeginHorizontal();
bool isPrefabCamera = false;
if (editPlane.renderCameraForPrefab != null)
{
#if UNITY_3_4
isPrefabCamera = (EditorUtility.GetPrefabType(editPlane.renderCameraForPrefab) == PrefabType.Prefab);
#else
isPrefabCamera = (PrefabUtility.GetPrefabType(editPlane.renderCameraForPrefab) == PrefabType.Prefab);
#endif
}
editPlane.renderCamera = (Camera)EditorGUILayout.ObjectField("Camera"
, isPrefabCamera ? editPlane.renderCameraForPrefab : null
, typeof(Camera)
, false
, GUILayout.Width(300));
labelStyle.fontStyle = FontStyle.Bold;
labelStyle.normal.textColor = Color.yellow;
GUILayout.Label("(Prefab Only)", labelStyle);
GUILayout.EndHorizontal();
GUILayout.Space(5);
}
else
{
editPlane.renderCamera = (Camera)EditorGUILayout.ObjectField("Camera"
, editPlane.renderCamera
, typeof(Camera)
, true
, GUILayout.Width(300));
}
EditorGUIUtility.LookLikeInspector();
// ========================================================
// anchor
// ========================================================
EditorGUILayout.LabelField("Anchor", "");
GUILayout.BeginHorizontal();
GUILayout.Space(30);
editPlane.anchor
= (exPlane.Anchor)GUILayout.SelectionGrid((int)editPlane.anchor,
anchorTexts,
3,
GUILayout.Width(80));
GUILayout.EndHorizontal();
// ========================================================
// use texture offset
// ========================================================
if (editSprite != null)
{
GUILayout.BeginHorizontal();
GUILayout.Space(30);
editSprite.useTextureOffset = GUILayout.Toggle(editSprite.useTextureOffset, "Use Texture Offset");
GUILayout.EndHorizontal();
}
GUI.enabled = true;
// ========================================================
// offset
// ========================================================
EditorGUIUtility.LookLikeControls();
editPlane.offset = EditorGUILayout.Vector2Field("Offset", editPlane.offset);
EditorGUIUtility.LookLikeInspector();
// ========================================================
// check dirty
// ========================================================
if (GUI.changed)
{
EditorUtility.SetDirty(editPlane);
}
--EditorGUI.indentLevel;
}
public override void OnInspectorGUI()
{
MegaModifyGroup mod = (MegaModifyGroup)target;
EditorGUIUtility.LookLikeControls();
MegaModifiers.GlobalDisplay = EditorGUILayout.Toggle("GlobalDisplayGizmos", MegaModifiers.GlobalDisplay);
mod.Enabled = EditorGUILayout.Toggle("Enabled", mod.Enabled);
mod.recalcnorms = EditorGUILayout.Toggle("Recalc Normals", mod.recalcnorms);
MegaNormalMethod method = mod.NormalMethod;
mod.NormalMethod = (MegaNormalMethod)EditorGUILayout.EnumPopup("Normal Method", mod.NormalMethod);
mod.recalcbounds = EditorGUILayout.Toggle("Recalc Bounds", mod.recalcbounds);
mod.recalcCollider = EditorGUILayout.Toggle("Recalc Collider", mod.recalcCollider);
mod.recalcTangents = EditorGUILayout.Toggle("Recalc Tangents", mod.recalcTangents);
mod.DoLateUpdate = EditorGUILayout.Toggle("Do Late Update", mod.DoLateUpdate);
mod.GrabVerts = EditorGUILayout.Toggle("Grab Verts", mod.GrabVerts);
mod.DrawGizmos = EditorGUILayout.Toggle("Draw Gizmos", mod.DrawGizmos);
if (mod.NormalMethod != method && mod.NormalMethod == MegaNormalMethod.Mega)
{
mod.BuildNormalMapping(mod.mesh, false);
}
if (GUILayout.Button("Threading Options"))
{
showmulti = !showmulti;
}
if (showmulti)
{
MegaModifiers.ThreadingOn = EditorGUILayout.Toggle("Threading Enabled", MegaModifiers.ThreadingOn);
mod.UseThreading = EditorGUILayout.Toggle("Thread This Object", mod.UseThreading);
}
EditorGUIUtility.LookLikeControls();
if (GUI.changed)
{
EditorUtility.SetDirty(target);
}
showorder = EditorGUILayout.Foldout(showorder, "Modifier Order");
if (showorder && mod.mods != null)
{
for (int i = 0; i < mod.mods.Length; i++)
{
EditorGUILayout.LabelField("", i.ToString() + " - " + mod.mods[i].ModName() + " " + mod.mods[i].Order);
}
}
if (GUILayout.Button("Targets"))
{
targetsFlag = !targetsFlag;
}
if (targetsFlag)
{
if (GUILayout.Button("Add Target"))
{
MegaModifierTarget targ = new MegaModifierTarget();
mod.targets.Add(targ);
}
for (int i = 0; i < mod.targets.Count; i++)
{
EditorGUILayout.BeginHorizontal();
mod.targets[i].go = (GameObject)EditorGUILayout.ObjectField("Target " + i, mod.targets[i].go, typeof(GameObject), true);
if (GUILayout.Button("Del"))
{
mod.targets.Remove(mod.targets[i]);
i--;
}
EditorGUILayout.EndHorizontal();
}
}
}
/// <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();
}
}
}
}
void DrawClipEditor(tk2dSpriteAnimationClip clip)
{
EditorGUIUtility.LookLikeControls(80.0f, 50.0f);
var frameBorderStyle = EditorStyles.textField;
int clipNumFrames = clip.frames.Length;
if (tk2dPreferences.inst.horizontalAnimDisplay)
{
scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition, GUILayout.Height(144.0f));
EditorGUILayout.BeginHorizontal();
for (int i = 0; i < clipNumFrames; ++i)
{
int frameCount = GetFrameCount(clip, i);
EditorGUILayout.BeginHorizontal(frameBorderStyle);
EditorGUILayout.BeginVertical();
GUILayout.Label(new GUIContent(i.ToString(), "Frame"));
// GUILayout.Label(new GUIContent((i / clip.fps).ToString("0.00" + "s"), "Time"));
EditorGUILayout.EndVertical();
DrawSpritePreview(clip.frames[i].spriteCollection, clip.frames[i].spriteId);
EditorGUILayout.BeginVertical();
DrawFrameEditor(clip, i, frameCount);
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.Space();
i += (frameCount - 1);
}
DrawAddFrame(clip, false);
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndScrollView();
}
else
{
scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
EditorGUILayout.BeginVertical();
for (int i = 0; i < clipNumFrames; ++i)
{
int frameCount = GetFrameCount(clip, i);
EditorGUILayout.BeginHorizontal(frameBorderStyle);
EditorGUILayout.BeginVertical();
GUILayout.Label(new GUIContent(i.ToString(), "Frame"));
// GUILayout.Label(new GUIContent((i / clip.fps).ToString("0.00" + "s"), "Time"));
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical();
DrawFrameEditor(clip, i, frameCount);
EditorGUILayout.EndVertical();
DrawSpritePreview(clip.frames[i].spriteCollection, clip.frames[i].spriteId);
EditorGUILayout.EndHorizontal();
i += (frameCount - 1);
}
DrawAddFrame(clip, true);
EditorGUILayout.EndVertical();
EditorGUILayout.EndScrollView();
}
if (deferredFrameOp != null)
{
deferredFrameOp(clip);
deferredFrameOp = null;
GUI.changed = true;
}
}
public static void TagsMaskField(GUIContent changeLabel, GUIContent setLabel, ref Pathfinding.TagMask value)
{
GUILayout.BeginHorizontal();
EditorGUIUtility.LookLikeControls();
EditorGUILayout.PrefixLabel(changeLabel, EditorStyles.layerMaskField);
string text = "";
if (value.tagsChange == 0)
{
text = "Nothing";
}
else if (value.tagsChange == ~0)
{
text = "Everything";
}
else
{
text = System.Convert.ToString(value.tagsChange, 2);
}
if (GUILayout.Button(text, EditorStyles.layerMaskField, GUILayout.ExpandWidth(true)))
{
GenericMenu menu = new GenericMenu();
menu.AddItem(new GUIContent("Everything"), value.tagsChange == ~0, value.SetValues, new Pathfinding.TagMask(~0, value.tagsSet));
menu.AddItem(new GUIContent("Nothing"), value.tagsChange == 0, value.SetValues, new Pathfinding.TagMask(0, value.tagsSet));
for (int i = 0; i < 32; i++)
{
bool on = (value.tagsChange >> i & 0x1) != 0;
Pathfinding.TagMask result = new Pathfinding.TagMask(on ? value.tagsChange & ~(1 << i) : value.tagsChange | 1 << i, value.tagsSet);
menu.AddItem(new GUIContent("" + i), on, value.SetValues, result);
}
menu.ShowAsContext();
Event.current.Use();
}
#if UNITY_LE_4_3
EditorGUIUtility.LookLikeInspector();
#endif
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
EditorGUIUtility.LookLikeControls();
EditorGUILayout.PrefixLabel(setLabel, EditorStyles.layerMaskField);
text = "";
if (value.tagsSet == 0)
{
text = "Nothing";
}
else if (value.tagsSet == ~0)
{
text = "Everything";
}
else
{
text = System.Convert.ToString(value.tagsSet, 2);
}
if (GUILayout.Button(text, EditorStyles.layerMaskField, GUILayout.ExpandWidth(true)))
{
GenericMenu menu = new GenericMenu();
if (value.tagsChange != 0)
{
menu.AddItem(new GUIContent("Everything"), value.tagsSet == ~0, value.SetValues, new Pathfinding.TagMask(value.tagsChange, ~0));
}
else
{
menu.AddDisabledItem(new GUIContent("Everything"));
}
menu.AddItem(new GUIContent("Nothing"), value.tagsSet == 0, value.SetValues, new Pathfinding.TagMask(value.tagsChange, 0));
for (int i = 0; i < 32; i++)
{
bool enabled = (value.tagsChange >> i & 0x1) != 0;
bool on = (value.tagsSet >> i & 0x1) != 0;
Pathfinding.TagMask result = new Pathfinding.TagMask(value.tagsChange, on ? value.tagsSet & ~(1 << i) : value.tagsSet | 1 << i);
if (enabled)
{
menu.AddItem(new GUIContent("" + i), on, value.SetValues, result);
}
else
{
menu.AddDisabledItem(new GUIContent("" + i));
}
}
menu.ShowAsContext();
Event.current.Use();
}
#if UNITY_LE_4_3
EditorGUIUtility.LookLikeInspector();
#endif
GUILayout.EndHorizontal();
}
public override void OnInspectorGUI()
{
EditorGUIUtility.LookLikeControls(80f);
mMogoButton = target as MogoSingleButton;
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
var isImage = EditorGUILayout.Toggle("isImage", mMogoButton.isImage, GUILayout.Width(250f));
if (isImage != mMogoButton.isImage)
{
RegisterUndo(); mMogoButton.isImage = isImage;
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
var BGDown = EditorGUILayout.ObjectField("BGDown", mMogoButton.BGDown, typeof(GameObject)) as GameObject;
if (BGDown != mMogoButton.BGDown)
{
RegisterUndo(); mMogoButton.BGDown = BGDown;
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
var BGUp = EditorGUILayout.ObjectField("BGUp", mMogoButton.BGUp, typeof(GameObject)) as GameObject;
if (BGUp != mMogoButton.BGUp)
{
RegisterUndo(); mMogoButton.BGUp = BGUp;
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
var TextFG = EditorGUILayout.ObjectField("TextFG", mMogoButton.TextFG, typeof(GameObject)) as GameObject;
if (TextFG != mMogoButton.TextFG)
{
RegisterUndo(); mMogoButton.TextFG = TextFG;
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
var m_lblName = EditorGUILayout.ObjectField("m_lblName", mMogoButton.m_lblName, typeof(UILabel)) as UILabel;
if (m_lblName != mMogoButton.m_lblName)
{
RegisterUndo(); mMogoButton.m_lblName = m_lblName;
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
var buttonType = (ButtonClickSoundType)EditorGUILayout.EnumPopup("buttonType", mMogoButton.buttonType, GUILayout.Width(170f));
if (buttonType != mMogoButton.buttonType)
{
RegisterUndo(); mMogoButton.buttonType = buttonType;
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("一秒变样式", GUILayout.Width(75f));
//if (GUILayout.Button("A横上选中", GUILayout.Width(100f)))
// ExportScenesManager.SetUIASingleButton(mMogoButton.gameObject, true);
//if (GUILayout.Button("A横上普通", GUILayout.Width(100f)))
// ExportScenesManager.SetUIASingleButton(mMogoButton.gameObject, false);
//GUILayout.EndHorizontal();
//GUILayout.BeginHorizontal();
//GUILayout.Label("", GUILayout.Width(75f));
//if (GUILayout.Button("B竖左选中", GUILayout.Width(100f)))
// ExportScenesManager.SetUIBSingleButton(mMogoButton.gameObject, true);
//if (GUILayout.Button("B竖左普通", GUILayout.Width(100f)))
// ExportScenesManager.SetUIBSingleButton(mMogoButton.gameObject, false);
//GUILayout.EndHorizontal();
//GUILayout.BeginHorizontal();
//GUILayout.Label("", GUILayout.Width(75f));
//if (GUILayout.Button("C横左选中", GUILayout.Width(100f)))
// ExportScenesManager.SetUICSingleButton(mMogoButton.gameObject, true);
//if (GUILayout.Button("C横左普通", GUILayout.Width(100f)))
// ExportScenesManager.SetUICSingleButton(mMogoButton.gameObject, false);
//GUILayout.EndHorizontal();
//GUILayout.BeginHorizontal();
//GUILayout.Label("", GUILayout.Width(75f));
//if (GUILayout.Button("D子页签选中", GUILayout.Width(120f)))
// ExportScenesManager.SetUIDSingleButton(mMogoButton.gameObject, true);
//if (GUILayout.Button("D子页签普通", GUILayout.Width(120f)))
// ExportScenesManager.SetUIDSingleButton(mMogoButton.gameObject, false);
GUILayout.EndHorizontal();
}
public override void OnInspectorGUI()
{
TV_Orbit myTarget = (TV_Orbit)target;
EditorGUILayout.Space();
GUILayout.Label("ForceX Tools: Planet & Orbit Editor");
GUILayout.Label("Version 1.0.1");
EditorGUILayout.Space();
EditorGUILayout.Space();
myTarget.TimeMultiplier = EditorGUILayout.IntField("Time Multiplier: ", myTarget.TimeMultiplier);
myTarget.Name = EditorGUILayout.TextField("Name: ", myTarget.Name);
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.Space();
//EditorGUIUtility.LookLikeInspector();
myTarget.Parent = (Transform)EditorGUILayout.ObjectField("Parent Mass: ", myTarget.Parent, typeof(Transform), true);
EditorGUIUtility.LookLikeControls();
EditorGUILayout.Space();
myTarget.LockOrbit = EditorGUILayout.Toggle("Lock Orbit:", myTarget.LockOrbit);
myTarget.TidalLock = EditorGUILayout.Toggle("Tidal Lock:", myTarget.TidalLock);
EditorGUILayout.Space();
EditorGUILayout.Space();
GUILayout.Label("Orbit Display ------------------------------", EditorStyles.boldLabel);
myTarget._DrawOrbit = EditorGUILayout.Toggle("Draw Orbit:", myTarget._DrawOrbit);
if (myTarget._DrawOrbit == true)
{
myTarget.Segments = EditorGUILayout.IntField("Display Segments: ", myTarget.Segments);
myTarget.DisplaySize = EditorGUILayout.FloatField("Display Size: ", myTarget.DisplaySize);
myTarget.DisplayColor = EditorGUILayout.ColorField("Display Color: ", myTarget.DisplayColor);
EditorGUILayout.Space();
myTarget.UseTexture = EditorGUILayout.Toggle("Use Texture:", myTarget.UseTexture);
if (myTarget.UseTexture == true)
{
//EditorGUIUtility.LookLikeInspector();
myTarget.DisplayTexture = (Texture2D)EditorGUILayout.ObjectField("Display Texture: ", myTarget.DisplayTexture, typeof(Texture2D), true);
EditorGUIUtility.LookLikeControls();
myTarget.DisplayTiling = EditorGUILayout.IntField("Texture Tiling: ", myTarget.DisplayTiling);
}
}
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.Space();
//SetupPlanet = EditorGUILayout.EnumPopup("Planet Options:",SetupPlanet);
GUILayout.Label("Planet Orbit ------------------------------", EditorStyles.boldLabel);
EditorGUILayout.Space();
//if(SetupPlanet == 0){
myTarget.AxialTilt = EditorGUILayout.Slider("Axial Tilt: ", myTarget.AxialTilt, 0, 360);
myTarget.OrbitalDistance = EditorGUILayout.FloatField("Orbital Distance: ", myTarget.OrbitalDistance);
myTarget.OrbitAngle = EditorGUILayout.FloatField("Orbit Angle: ", myTarget.OrbitAngle);
EditorGUILayout.Space();
myTarget.OrbitOffset = EditorGUILayout.Vector3Field("Orbit Center Offset: ", myTarget.OrbitOffset);
EditorGUILayout.Space();
EditorGUILayout.Space();
myTarget.OrbitPosOffset = EditorGUILayout.Slider("Start Orbital Offset: ", myTarget.OrbitPosOffset, 0, 360);
EditorGUILayout.Space();
if (!myTarget.LockOrbit)
{
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.Space();
myTarget.SetOrbit = (TV_Orbit.Orbit)EditorGUILayout.EnumPopup("Set Orbit:", myTarget.SetOrbit);
EditorGUILayout.Space();
if (myTarget.SetOrbit == 0)
{
GUILayout.Label("Orbital Period x1 Earth Years");
myTarget.OrbitalPeriod = EditorGUILayout.FloatField("Orbital Period: ", myTarget.OrbitalPeriod);
}
else
{
GUILayout.Label("Orbital Period In Earth Time");
myTarget.OrbitYears = EditorGUILayout.IntField("Orbit Years: ", myTarget.OrbitYears);
myTarget.OrbitDays = EditorGUILayout.IntField("Orbit Days: ", myTarget.OrbitDays);
myTarget.OrbitHours = EditorGUILayout.IntField("Orbit Hours: ", myTarget.OrbitHours);
myTarget.OrbitMinutes = EditorGUILayout.IntField("Orbit Minutes: ", myTarget.OrbitMinutes);
myTarget.OrbitSeconds = EditorGUILayout.FloatField("Orbit Seconds: ", myTarget.OrbitSeconds);
}
}
//}else
//if(SetupPlanet == 1){
if (!myTarget.TidalLock)
{
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.Space();
GUILayout.Label("Planet Rotation ------------------------------", EditorStyles.boldLabel);
EditorGUILayout.Space();
myTarget.SetRotation = (TV_Orbit.Rotation)EditorGUILayout.EnumPopup("Set Rotation:", myTarget.SetRotation);
EditorGUILayout.Space();
if (myTarget.SetRotation == 0)
{
GUILayout.Label("Rotation Period x1 Earth Days");
myTarget.RotationPeriod = EditorGUILayout.FloatField("Orbital Period: ", myTarget.OrbitalPeriod);
}
else
{
GUILayout.Label("Rotation Period In Earth Time");
myTarget.RotationYears = EditorGUILayout.IntField("Rotation Years: ", myTarget.RotationYears);
myTarget.RotationDays = EditorGUILayout.IntField("Rotation Days: ", myTarget.RotationDays);
myTarget.RotationHours = EditorGUILayout.IntField("Rotation Hours: ", myTarget.RotationHours);
myTarget.RotationMinutes = EditorGUILayout.IntField("Rotation Minutes: ", myTarget.RotationMinutes);
myTarget.RotationSeconds = EditorGUILayout.FloatField("Rotation Seconds: ", myTarget.RotationSeconds);
}
}
//}
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.Space();
if (!myTarget.LockOrbit)
{
GUILayout.Label("Local Planetary Statistics --------------------", EditorStyles.boldLabel);
EditorGUILayout.Space();
//GUILayout.Label("Allow Start Orbital Offset To Effect Year");
//target.OrbitOffSetYear = EditorGUILayout.Toggle("Enabled:", target.OrbitOffSetYear);
myTarget.CurrentOrbitPos = EditorGUILayout.Slider("Orbital Position: ", myTarget.CurrentOrbitPos, 0, 360);
EditorGUILayout.Space();
myTarget.KeepTime = EditorGUILayout.Toggle("Keep Local Time:", myTarget.KeepTime);
if (myTarget.KeepTime == true)
{
//EditorGUIUtility.LookLikeInspector();
myTarget.CounterYear = EditorGUILayout.IntField(" Orbits: ", myTarget.CounterYear);
if (!myTarget.TidalLock)
{
myTarget.CounterDay = EditorGUILayout.IntField(" Rotations: ", myTarget.CounterDay);
EditorGUILayout.Space();
myTarget.RotInOrbit = EditorGUILayout.IntField(" Rotations Per Orbit: ", myTarget.RotInOrbit);
myTarget.HoursInDay = EditorGUILayout.IntField(" Hours Per Rotation: ", myTarget.HoursInDay);
EditorGUILayout.Space();
GUILayout.Label("Current Local Time");
myTarget.CounterHour = (int)EditorGUILayout.FloatField(" Hours: ", myTarget.CounterHour);
myTarget.CounterMinute = (int)EditorGUILayout.FloatField(" Minutes: ", myTarget.CounterMinute);
myTarget.CounterSecond = EditorGUILayout.FloatField(" Seconds: ", myTarget.CounterSecond);
}
}
}
}
public override void OnInspectorGUI()
{
MegaWrap mod = (MegaWrap)target;
#if !UNITY_5 && !UNITY_2017 && !UNITY_2018 && !UNITY_2019 && !UNITY_2020
EditorGUIUtility.LookLikeControls();
#endif
mod.WrapEnabled = EditorGUILayout.Toggle("Enabled", mod.WrapEnabled);
mod.target = (MegaModifyObject)EditorGUILayout.ObjectField("Target", mod.target, typeof(MegaModifyObject), true);
float max = 1.0f;
if (mod.target)
{
max = mod.target.bbox.size.magnitude;
}
mod.maxdist = EditorGUILayout.Slider("Max Dist", mod.maxdist, 0.0f, max); //2.0f); //mod.maxdist);
if (mod.maxdist < 0.0f)
{
mod.maxdist = 0.0f;
}
mod.maxpoints = EditorGUILayout.IntField("Max Points", mod.maxpoints); //mod.maxdist);
if (mod.maxpoints < 1)
{
mod.maxpoints = 1;
}
Color col = GUI.backgroundColor;
EditorGUILayout.BeginHorizontal();
if (mod.bindverts == null)
{
GUI.backgroundColor = Color.red;
if (GUILayout.Button("Map"))
{
Attach(mod.target);
}
}
else
{
GUI.backgroundColor = Color.green;
if (GUILayout.Button("ReMap"))
{
Attach(mod.target);
}
}
GUI.backgroundColor = col;
if (GUILayout.Button("Reset"))
{
mod.ResetMesh();
}
EditorGUILayout.EndHorizontal();
if (GUI.changed)
{
EditorUtility.SetDirty(mod);
}
mod.gap = EditorGUILayout.FloatField("Gap", mod.gap);
mod.shrink = EditorGUILayout.Slider("Shrink", mod.shrink, 0.0f, 1.0f);
mod.size = EditorGUILayout.Slider("Size", mod.size, 0.001f, 0.04f);
if (mod.bindverts != null)
{
mod.vertindex = EditorGUILayout.IntSlider("Vert Index", mod.vertindex, 0, mod.bindverts.Length - 1);
}
mod.offset = EditorGUILayout.Vector3Field("Offset", mod.offset);
mod.NormalMethod = (MegaNormalMethod)EditorGUILayout.EnumPopup("Normal Method", mod.NormalMethod);
#if UNITY_5 || UNITY_2017 || UNITY_2018 || UNITY_2019 || UNITY_2020
mod.UseBakedMesh = EditorGUILayout.Toggle("Use Baked Mesh", mod.UseBakedMesh);
#endif
if (mod.bindverts == null || mod.target == null)
{
EditorGUILayout.LabelField("Object not wrapped");
}
else
{
EditorGUILayout.LabelField("UnMapped", mod.nomapcount.ToString());
}
if (GUI.changed)
{
EditorUtility.SetDirty(mod);
}
}
/// <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);
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 <NGUIFont>() != 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 <NGUIFont>("Select", NGUISettings.font, OnSelectFont);
ComponentSelector.Draw <NGUIAtlas>(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 <NGUIFont>() != 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;
}
else if (create != 1)
{
NGUIAtlasMaker.AddOrUpdate(NGUISettings.atlas, NGUISettings.fontTexture);
}
// Font doesn't exist yet
if (go == null || go.GetComponent <NGUIFont>() == 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 <NGUIFont>();
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 <NGUIFont>();
}
else
{
NGUISettings.font = go.GetComponent <NGUIFont>();
CreateFont(NGUISettings.font, create, mat);
}
MarkAsChanged();
}
}
}
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();
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);
}
}
}
}
public override void OnInspectorGUI()
{
Transform t = (Transform)target;
if (GUILayout.Button("Reset Transforms"))
{
Undo.RecordObject(t, "Reset Transforms " + t.name);
if (t.parent == null)
{
t.transform.position = Vector3.zero;
t.transform.rotation = Quaternion.identity;
t.transform.localScale = Vector3.one;
}
else
{
t.transform.localPosition = Vector3.zero;
t.transform.localRotation = Quaternion.identity;
t.transform.localScale = Vector3.one;
}
}
if (GUILayout.Button("Reset Position"))
{
Undo.RecordObject(t, "Reset Position " + t.name);
if (t.parent == null)
{
t.transform.position = Vector3.zero;
}
else
{
t.transform.localPosition = Vector3.zero;
}
}
if (GUILayout.Button("Reset Rotation"))
{
Undo.RecordObject(t, "Reset Rotation " + t.name);
if (t.parent == null)
{
t.transform.rotation = Quaternion.identity;
}
else
{
t.transform.localRotation = Quaternion.identity;
}
}
if (GUILayout.Button("Reset Scale"))
{
Undo.RecordObject(t, "Reset Scale " + t.name);
t.transform.localScale = Vector3.one;
}
// Replicate the standard transform inspector gui
EditorGUIUtility.LookLikeControls();
EditorGUI.indentLevel = 0;
Vector3 position = EditorGUILayout.Vector3Field("Position", t.localPosition);
Vector3 eulerAngles = EditorGUILayout.Vector3Field("Rotation", t.localEulerAngles);
Vector3 scale = EditorGUILayout.Vector3Field("Scale", t.localScale);
EditorGUIUtility.LookLikeControls();
if (GUI.changed)
{
Undo.RecordObject(t, "Transform Change");
t.localPosition = FixIfNaN(position);
t.localEulerAngles = FixIfNaN(eulerAngles);
t.localScale = FixIfNaN(scale);
}
}
protected override void OnGUIButtons()
{
DebugContext.SetViews(ViewOption.Grid | ViewOption.Selection | ViewOption.Mesh);
NavmeshBuild build = Context.Build;
if (!build)
{
return;
}
TileBuildData tdata = build.BuildData;
if (tdata == null)
{
return;
}
TileSelection selection = Context.Selection;
bool hasSelection = selection.Validate();
bool needBaking = (tdata.NeedsBakingCount() > 0);
int activeCount = Context.TaskCount;
int bakeableCount = tdata.BakeableCount();
bool origGUIEnabled = GUI.enabled;
bool guiEnabled = !IsBaseBusy;
GUI.enabled = guiEnabled;
ControlUtil.BeginButtonArea(Context.ButtonArea);
if (GUILayout.Button("Build All"))
{
HandleBuildRequest(true);
}
GUI.enabled = guiEnabled && hasSelection;
if (GUILayout.Button("Build Zone"))
{
HandleBuildRequest(false);
}
////////////////////////////////////////////////////////////////////
GUILayout.Space(MarginSize);
// Only disable baking if there is nothing at all that can be baked.
GUI.enabled = guiEnabled && activeCount == 0 && (bakeableCount > 0);
GUIStyle style = (bakeableCount > 0 && activeCount == 0)
? ControlUtil.HighlightedButton : GUI.skin.button;
if (GUILayout.Button("Bake All", style))
{
HandleBake();
}
////////////////////////////////////////////////////////////////////
GUILayout.Space(MarginSize);
// Note: Technically only the last condition is needed. But checking the
// other conditions first saves processing time.
GUI.enabled = guiEnabled && activeCount == 0 &&
tdata.GetStateCount(TileBuildState.NotBuilt) < tdata.Width * tdata.Depth;
if (GUILayout.Button((needBaking ? "Revert Unbaked" : "Clear All")))
{
HandleClear();
}
GUI.enabled = guiEnabled && (activeCount != 0);
if (GUILayout.Button("Abort Builds"))
{
Context.AbortAllReqests("User requested.");
}
////////////////////////////////////////////////////////////////////
GUILayout.Space(ControlUtil.MarginSize);
GUI.enabled = guiEnabled;
if (OnGUIStandardButtons())
{
// Special case. Build was discarded.
ControlUtil.EndButtonArea();
return;
}
///////////////////////////////////////////////////////////////////
GUILayout.Space(MarginSize);
GUI.enabled = guiEnabled && hasSelection;
EditorGUIUtility.LookLikeControls(100);
selection.ZoneSize = EditorGUILayout.IntField("Zone Size", selection.ZoneSize);
EditorGUIUtility.LookLikeControls();
GUI.enabled = guiEnabled;
////////////////////////////////////////////////////////////////////
GUILayout.Space(MarginSize);
GUILayout.Label("Bakeable Tiles: " + bakeableCount);
ControlUtil.OnGUIStandardButtons(Context, DebugContext, true);
ControlUtil.EndButtonArea();
GUI.enabled = origGUIEnabled;
}
public override void OnInspectorGUI()
{
EditorGUIUtility.LookLikeControls();
Mode oldMode = mode;
mode = (Mode)EditorGUIUtils.Toolbar(mode);
EditorGUILayout.Separator();
if (mode != oldMode)
{
EditorGUIUtility.keyboardControl = 0;
}
if (mode == Mode.AtlasSet)
{
DrawAtlasesList(blockSet);
if (blockSet.GetAtlas(selectedAtlas) != null)
{
DrawAtlasEditor(blockSet.GetAtlas(selectedAtlas));
}
}
if (mode == Mode.BlockSet)
{
DrawBlockSet(blockSet);
EditorGUILayout.Separator();
if (selectedBlock < blockSet.GetBlockCount() && blockSet.GetBlock(selectedBlock) != null)
{
BlockEditor.DrawBlockEditor(blockSet.GetBlock(selectedBlock), blockSet);
}
if (selectedBlock >= blockSet.GetBlockCount() && blockSet.GetItem(selectedBlock - blockSet.GetBlockCount()) != null)
{
BlockEditor.DrawItemEditor(blockSet.GetItem(selectedBlock - blockSet.GetBlockCount()), blockSet);
}
}
if (mode == Mode.XML)
{
if (oldMode != mode)
{
xml = blockSet.GetData();
}
xmlScrollPosition = GUILayout.BeginScrollView(xmlScrollPosition);
GUIStyle style = new GUIStyle(GUI.skin.box);
style.alignment = TextAnchor.UpperLeft;
xml = EditorGUILayout.TextArea(xml, GUILayout.ExpandWidth(true));
blockSet.SetData(xml);
GUILayout.EndScrollView();
if (GUILayout.Button("Import"))
{
BlockSetImport.Import(blockSet, blockSet.GetData());
GUI.changed = true;
}
}
if (GUI.changed)
{
string data = BlockSetExport.Export(blockSet);
blockSet.SetData(data);
EditorUtility.SetDirty(blockSet);
}
}
public bool Draw(List <SpriteCollectionEditorEntry> selectedEntries)
{
if (selectedEntries.Count == 0 || selectedEntries[0].type != SpriteCollectionEditorEntry.Type.SpriteSheet)
{
return(false);
}
var entry = selectedEntries[selectedEntries.Count - 1];
var spriteSheet = SpriteCollection.spriteSheets[entry.index];
if (activeSpriteSheetSource != spriteSheet)
{
// reset state data
selectedSprites.Clear();
activeSelectedSprites.Clear();
rectSelectX = rectSelectY = -1;
textureViewScrollBar = Vector2.zero;
inspectorScrollBar = Vector2.zero;
activeSpriteSheetSource = spriteSheet;
selectedMode = EditMode.Edit;
}
if (spriteSheet.tileWidth == 0 || spriteSheet.tileHeight == 0)
{
selectedMode = EditMode.Config;
}
bool doDelete = false;
GUILayout.BeginHorizontal();
// Texture View
GUILayout.BeginVertical(tk2dEditorSkin.SC_BodyBackground, GUILayout.ExpandHeight(true), GUILayout.ExpandWidth(true));
textureViewScrollBar = GUILayout.BeginScrollView(textureViewScrollBar);
if (spriteSheet.texture != null)
{
spriteSheet.texture.filterMode = FilterMode.Point;
DrawTextureView(spriteSheet);
host.OnSpriteCollectionChanged(true);
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
// Inspector
EditorGUIUtility.LookLikeControls(100.0f, 100.0f);
inspectorScrollBar = GUILayout.BeginScrollView(inspectorScrollBar, GUILayout.ExpandHeight(true), GUILayout.Width(host.InspectorWidth));
// Header
GUILayout.BeginVertical(tk2dEditorSkin.SC_InspectorHeaderBG, GUILayout.ExpandWidth(true));
GUILayout.Label("Sprite Sheet");
GUILayout.BeginHorizontal();
Texture2D newTexture = EditorGUILayout.ObjectField("Texture", spriteSheet.texture, typeof(Texture2D), false) as Texture2D;
if (newTexture != spriteSheet.texture)
{
spriteSheet.texture = newTexture;
host.OnSpriteCollectionSortChanged();
}
GUILayout.FlexibleSpace();
if (GUILayout.Button("Delete", EditorStyles.miniButton))
{
doDelete = true;
}
GUILayout.EndHorizontal();
GUILayout.EndVertical();
bool textureReady = false;
if (spriteSheet.texture != null)
{
GUILayout.BeginVertical(tk2dEditorSkin.SC_InspectorBG, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false));
string assetPath = AssetDatabase.GetAssetPath(spriteSheet.texture);
if (assetPath.Length > 0)
{
// make sure the source texture is npot and readable, and uncompressed
if (tk2dSpriteCollectionBuilder.IsTextureImporterSetUp(assetPath))
{
textureReady = true;
}
else
{
if (tk2dGuiUtility.InfoBoxWithButtons(
"The texture importer needs to be reconfigured to be used as a sprite sheet source. " +
"Please note that this will globally change this texture importer.",
tk2dGuiUtility.WarningLevel.Info,
"Set up") != -1)
{
tk2dSpriteCollectionBuilder.ConfigureSpriteTextureImporter(assetPath);
AssetDatabase.ImportAsset(assetPath);
}
}
}
GUILayout.EndVertical();
}
// Body
if (textureReady)
{
GUILayout.BeginVertical(tk2dEditorSkin.SC_InspectorBG, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false));
selectedMode = (EditMode)GUILayout.Toolbar((int)selectedMode, new string[] { "Edit", "Config" });
EditorGUILayout.Space();
GUILayout.EndVertical();
if (selectedMode == EditMode.Edit)
{
if (Event.current.type == EventType.Layout)
{
activeSelectedSprites = new List <SpriteCollectionEditorEntry>(selectedSprites);
}
if (activeSelectedSprites.Count > 0)
{
host.SpriteView.DrawSpriteEditorInspector(activeSelectedSprites, true, true);
}
}
else
{
GUILayout.BeginVertical(tk2dEditorSkin.SC_InspectorBG, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false));
spriteSheet.tileWidth = EditorGUILayout.IntField("Tile Width", spriteSheet.tileWidth);
spriteSheet.tileHeight = EditorGUILayout.IntField("Tile Height", spriteSheet.tileHeight);
spriteSheet.tileMarginX = EditorGUILayout.IntField("Tile Margin X", spriteSheet.tileMarginX);
spriteSheet.tileMarginY = EditorGUILayout.IntField("Tile Margin Y", spriteSheet.tileMarginY);
spriteSheet.tileSpacingX = EditorGUILayout.IntField("Tile Spacing X", spriteSheet.tileSpacingX);
spriteSheet.tileSpacingY = EditorGUILayout.IntField("Tile Spacing Y", spriteSheet.tileSpacingY);
// Apply button
GUILayout.Space(8);
GUILayout.BeginHorizontal(); GUILayout.FlexibleSpace();
if (spriteSheet.texture != null &&
spriteSheet.tileWidth > 0 && spriteSheet.tileWidth <= spriteSheet.texture.width &&
spriteSheet.tileHeight > 0 && spriteSheet.tileHeight <= spriteSheet.texture.height &&
GUILayout.Button("Apply", EditorStyles.miniButton))
{
AddSprites(spriteSheet);
selectedMode = EditMode.Edit;
}
GUILayout.EndHorizontal();
GUILayout.EndVertical();
}
}
GUILayout.BeginVertical(tk2dEditorSkin.SC_InspectorBG, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
GUILayout.EndVertical();
// /Body
GUILayout.EndScrollView();
GUILayout.EndHorizontal();
if (doDelete)
{
string message = "Deleting a sprite sheet will delete all sprites sourced from this sprite sheet. " +
"Are you sure you want to do this?";
if (EditorUtility.DisplayDialog("Delete sprite sheet", message, "Yes", "No"))
{
SpriteCollection.DeleteSpriteSheet(spriteSheet);
host.OnSpriteCollectionChanged(false);
}
}
return(true);
}
/// <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("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);
}
}
}
public override void OnInspectorGUI()
{
MegaCacheOBJ mod = (MegaCacheOBJ)target;
serializedObject.Update();
EditorGUIUtility.LookLikeControls();
EditorGUILayout.BeginVertical("box");
mod.showdataimport = EditorGUILayout.Foldout(mod.showdataimport, "Data Import");
if (mod.showdataimport)
{
EditorGUILayout.PropertyField(_prop_firstframe, new GUIContent("First"));
EditorGUILayout.PropertyField(_prop_lastframe, new GUIContent("Last"));
EditorGUILayout.PropertyField(_prop_skip, new GUIContent("Skip"));
int val = 0;
mod.decformat = EditorGUILayout.IntSlider("Format name" + val.ToString("D" + mod.decformat) + ".obj", mod.decformat, 1, 6);
mod.namesplit = EditorGUILayout.TextField("Name Split Char", mod.namesplit);
EditorGUILayout.PropertyField(_prop_scale, new GUIContent("Import Scale"));
EditorGUILayout.PropertyField(_prop_adjustcords, new GUIContent("Adjust Coords"));
EditorGUILayout.PropertyField(_prop_buildtangents, new GUIContent("Build Tangents"));
EditorGUILayout.PropertyField(_prop_updatecollider, new GUIContent("Update Collider"));
EditorGUILayout.PropertyField(_prop_loadmtls, new GUIContent("Load Materials"));
if (GUILayout.Button("Load Frames"))
{
string file = EditorUtility.OpenFilePanel("OBJ File", mod.lastpath, "obj");
if (file != null && file.Length > 1)
{
mod.lastpath = file;
LoadOBJ(mod, file, mod.firstframe, mod.lastframe, mod.skip);
}
}
if (mod.meshes.Count > 0)
{
if (GUILayout.Button("Clear Stored Meshes"))
{
mod.DestroyMeshes();
}
}
EditorGUILayout.EndVertical();
}
mod.showdata = EditorGUILayout.Foldout(mod.showdata, "Data");
if (mod.showdata)
{
MegaCacheData src = (MegaCacheData)EditorGUILayout.EnumPopup("Data Source", mod.datasource);
if (src != mod.datasource)
{
mod.ChangeSource(src);
}
switch (mod.datasource)
{
case MegaCacheData.Mesh:
if (mod.meshes.Count > 0)
{
EditorGUILayout.BeginVertical("box");
EditorGUILayout.PropertyField(_prop_saveuvs, new GUIContent("Save Uvs"));
EditorGUILayout.PropertyField(_prop_savenormals, new GUIContent("Save Normals"));
EditorGUILayout.PropertyField(_prop_savetangents, new GUIContent("Save Tangents"));
EditorGUILayout.PropertyField(_prop_optimize, new GUIContent("Optimize Data"));
if (GUILayout.Button("Save MegaCache File"))
{
string file = EditorUtility.SaveFilePanel("MegaCache File", mod.lastpath, mod.name, "mgc");
if (file != null && file.Length > 1)
{
mod.CloseCache();
CreateCacheFile(file);
if (mod.cachefile.Length == 0)
{
mod.cachefile = file;
}
}
}
if (GUILayout.Button("Create Image"))
{
CreateCacheImage();
}
EditorGUILayout.EndVertical();
}
break;
case MegaCacheData.File:
EditorGUILayout.BeginVertical("box");
EditorGUILayout.TextArea("Cache File: " + mod.cachefile);
if (GUILayout.Button("Select MegaCache File"))
{
string file = EditorUtility.OpenFilePanel("MegaCache File", mod.lastpath, "mgc");
if (file != null && file.Length > 1)
{
mod.CloseCache();
mod.cachefile = file;
mod.update = true;
mod.OpenCache(mod.cachefile);
}
}
EditorGUILayout.PropertyField(_prop_runtimefolder, new GUIContent("Runtime Folder"));
if (mod.cachefile.Length > 0)
{
if (GUILayout.Button("Create Image From Cache"))
{
bool doit = true;
if (mod.cacheimage)
{
if (!EditorUtility.DisplayDialog("Add to or Replace", "Image already loaded do you want to Replace?", "Yes", "No"))
{
doit = false;
}
}
if (doit)
{
mod.CreateImageFromCacheFile();
}
}
}
EditorGUILayout.EndVertical();
break;
case MegaCacheData.Image:
if (mod.cacheimage)
{
EditorGUILayout.BeginVertical("box");
#if !UNITY_FLASH && !UNITY_PS3 && !UNITY_METRO && !UNITY_WP8
mod.cacheimage.threadupdate = EditorGUILayout.Toggle("Preload", mod.cacheimage.threadupdate);
#endif
if (GUILayout.Button("Delete Image"))
{
mod.DestroyImage(); // = null;
}
EditorGUILayout.EndVertical();
}
break;
}
string info = "";
info += "Frame Verts: " + mod.framevertcount + "\nFrame Tris: " + (mod.frametricount / 3);
if (mod.datasource == MegaCacheData.Image)
{
if (mod.cacheimage)
{
info += "\nMemory: " + mod.cacheimage.memoryuse / (1024 * 1024) + "MB";
}
else
{
info += "\nNo Image File";
}
}
EditorGUILayout.HelpBox(info, MessageType.None);
}
mod.showanimation = EditorGUILayout.Foldout(mod.showanimation, "Animation");
if (mod.showanimation)
{
EditorGUILayout.BeginVertical("box");
int fc = 0;
switch (mod.datasource)
{
case MegaCacheData.Mesh: fc = mod.meshes.Count - 1; break;
case MegaCacheData.File: fc = mod.framecount - 1; break;
case MegaCacheData.Image:
if (mod.cacheimage && mod.cacheimage.frames != null)
{
fc = mod.cacheimage.frames.Count - 1;
}
break;
}
if (fc > 0)
{
EditorGUILayout.IntSlider(_prop_frame, 0, fc);
}
mod.animate = EditorGUILayout.BeginToggleGroup("Animate", mod.animate);
EditorGUILayout.PropertyField(_prop_time, new GUIContent("Time"));
EditorGUILayout.PropertyField(_prop_fps, new GUIContent("Fps"));
EditorGUILayout.PropertyField(_prop_speed, new GUIContent("Speed"));
EditorGUILayout.PropertyField(_prop_loopmode, new GUIContent("Loop Mode"));
EditorGUILayout.EndToggleGroup();
EditorGUILayout.EndVertical();
}
mod.showextras = EditorGUILayout.Foldout(mod.showextras, "Extra Options");
if (mod.showextras)
{
mod.shownormals = EditorGUILayout.BeginToggleGroup("Show Normals", mod.shownormals);
mod.normallen = EditorGUILayout.FloatField("Normal Length", mod.normallen);
EditorGUILayout.EndToggleGroup();
}
if (GUI.changed)
{
serializedObject.ApplyModifiedProperties();
EditorUtility.SetDirty(target);
}
}
public override void OnInspectorGUI()
{
//show default variables of manager
DrawDefaultInspector();
//get manager reference
script = (WaypointManager)target;
//get sceneview to auto-detect 2D mode
SceneView view = GetSceneView();
mode2D = view.in2DMode;
EditorGUIUtility.LookLikeControls();
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
//draw path text label
GUILayout.Label("Enter Path Name: ", GUILayout.Height(15));
//display text field for creating a path with that name
pathName = EditorGUILayout.TextField(pathName, GUILayout.Height(15));
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
//draw path type selection enum
GUILayout.Label("Select Path Type: ", GUILayout.Height(15));
pathType = (PathType)EditorGUILayout.EnumPopup(pathType);
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
//display label of current mode
if (mode2D)
{
GUILayout.Label("2D Mode Detected.", GUILayout.Height(15));
}
else
{
GUILayout.Label("3D Mode Detected.", GUILayout.Height(15));
}
EditorGUILayout.Space();
//draw path creation button
if (!placing && GUILayout.Button("Start Path", GUILayout.Height(40)))
{
if (pathName == "")
{
Debug.LogWarning("No path name defined. Cancelling.");
return;
}
if (script.transform.FindChild(pathName) != null)
{
Debug.LogWarning("Path name already given. Cancelling.");
return;
}
//create a new container transform which will hold all new waypoints
path = new GameObject(pathName);
//reset position and parent container gameobject to this manager gameobject
path.transform.position = script.gameObject.transform.position;
path.transform.parent = script.gameObject.transform;
StartPath();
//we passed all prior checks, toggle waypoint placement
placing = true;
//focus sceneview for placement
view.Focus();
}
GUI.backgroundColor = Color.yellow;
//finish path button
if (placing && GUILayout.Button("Finish Editing", GUILayout.Height(40)))
{
if (wpList.Count < 2)
{
Debug.LogWarning("Not enough waypoints placed. Cancelling.");
//if we have created a path already, destroy it again
if (path)
{
DestroyImmediate(path);
}
}
//toggle placement off
placing = false;
//clear list with temporary waypoint references,
//we only needed this for getting the waypoint count
wpList.Clear();
//reset path name input field
pathName = "";
//make the new path the active selection
Selection.activeGameObject = path;
}
GUI.backgroundColor = Color.white;
EditorGUILayout.Space();
//draw instructions
GUILayout.TextArea("Hint:\nPress 'Start Path' to begin a new path, then press 'p' on "
+ "your keyboard to place new waypoints in the SceneView. In 3D Mode "
+ "you have to place waypoints onto objects with colliders. You can "
+ "also place waypoints at the scene view position by pressing 'c'."
+ "\n\nPress 'Finish Editing' to end your path.");
}
/// <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 (NGUISettings.atlas != null && NGUISettings.atlas.name == NGUISettings.atlasName)
{
prefabPath = AssetDatabase.GetAssetPath(NGUISettings.atlas.gameObject.GetInstanceID());
if (NGUISettings.atlas.spriteMaterial != null)
{
matPath = AssetDatabase.GetAssetPath(NGUISettings.atlas.spriteMaterial.GetInstanceID());
}
}
// Assume default values if needed
if (string.IsNullOrEmpty(NGUISettings.atlasName))
{
NGUISettings.atlasName = "New Atlas";
}
if (string.IsNullOrEmpty(prefabPath))
{
prefabPath = NGUIEditorTools.GetSelectionFolder() + NGUISettings.atlasName + ".prefab";
}
if (string.IsNullOrEmpty(matPath))
{
matPath = NGUIEditorTools.GetSelectionFolder() + NGUISettings.atlasName + ".mat";
}
// Try to load the prefab
GameObject go = AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject)) as GameObject;
if (NGUISettings.atlas == null && go != null)
{
NGUISettings.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;
NGUISettings.atlasName = GUILayout.TextField(NGUISettings.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 " +
NGUISettings.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(NGUISettings.atlasPMA ? "Unlit/Premultiplied Colored" : "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 (NGUISettings.atlas == null || NGUISettings.atlas.name != NGUISettings.atlasName)
{
// Create a new prefab for the atlas
Object prefab = (go != null) ? go : PrefabUtility.CreateEmptyPrefab(prefabPath);
// Create a new game object for the atlas
go = new GameObject(NGUISettings.atlasName);
go.AddComponent <UIAtlas>().spriteMaterial = mat;
// Update the prefab
PrefabUtility.ReplacePrefab(go, prefab);
DestroyImmediate(go);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
// Select the atlas
go = AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject)) as GameObject;
NGUISettings.atlas = go.GetComponent <UIAtlas>();
}
}
}
ComponentSelector.Draw <UIAtlas>("Select", NGUISettings.atlas, OnSelectAtlas);
List <Texture> textures = GetSelectedTextures();
if (NGUISettings.atlas != null && NGUISettings.atlas.name == NGUISettings.atlasName)
{
Material mat = NGUISettings.atlas.spriteMaterial;
Texture tex = NGUISettings.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();
}
GUILayout.BeginHorizontal();
NGUISettings.atlasPadding = Mathf.Clamp(EditorGUILayout.IntField("Padding", NGUISettings.atlasPadding, GUILayout.Width(100f)), 0, 8);
GUILayout.Label((NGUISettings.atlasPadding == 1 ? "pixel" : "pixels") + " in-between of sprites");
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
NGUISettings.atlasTrimming = EditorGUILayout.Toggle("Trim Alpha", NGUISettings.atlasTrimming, GUILayout.Width(100f));
GUILayout.Label("Remove empty space");
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
NGUISettings.atlasPMA = EditorGUILayout.Toggle("PMA Shader", NGUISettings.atlasPMA, GUILayout.Width(100f));
GUILayout.Label("Pre-multiply color by alpha");
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
NGUISettings.unityPacking = EditorGUILayout.Toggle("Unity Packer", NGUISettings.unityPacking, GUILayout.Width(100f));
GUILayout.Label("if off, use a custom packer");
GUILayout.EndHorizontal();
if (!NGUISettings.unityPacking)
{
GUILayout.BeginHorizontal();
NGUISettings.forceSquareAtlas = EditorGUILayout.Toggle("Force Square", NGUISettings.forceSquareAtlas, GUILayout.Width(100f));
GUILayout.Label("if on, forces a square atlas texture");
GUILayout.EndHorizontal();
}
#if UNITY_IPHONE || UNITY_ANDROID
GUILayout.BeginHorizontal();
NGUISettings.allow4096 = EditorGUILayout.Toggle("4096x4096", NGUISettings.allow4096, GUILayout.Width(100f));
GUILayout.Label("if off, limit atlases to 2048x2048");
GUILayout.EndHorizontal();
#endif
if (NGUISettings.atlas != null && NGUISettings.atlas.name == NGUISettings.atlasName)
{
if (textures.Count > 0)
{
GUI.backgroundColor = Color.green;
update = GUILayout.Button("Add/Update All");
GUI.backgroundColor = Color.white;
}
else
{
EditorGUILayout.HelpBox("You can reveal more options by selecting one or more textures in the Project View window.", MessageType.Info);
}
}
else
{
EditorGUILayout.HelpBox("You can create a new atlas by selecting one or more textures in the Project View window, then clicking \"Create\".", MessageType.Info);
}
string selection = null;
Dictionary <string, int> spriteList = GetSpriteList(textures);
if (spriteList.Count > 0)
{
NGUIEditorTools.DrawHeader("Sprites");
GUILayout.Space(-7f);
mScroll = GUILayout.BeginScrollView(mScroll);
bool delete = false;
int index = 0;
foreach (KeyValuePair <string, int> iter in spriteList)
{
++index;
GUILayout.Space(-1f);
bool highlight = (UIAtlasInspector.instance != null) && (NGUISettings.selectedSprite == iter.Key);
GUI.backgroundColor = highlight ? Color.white : new Color(0.8f, 0.8f, 0.8f);
GUILayout.BeginHorizontal("AS TextArea", GUILayout.MinHeight(20f));
GUI.backgroundColor = Color.white;
GUILayout.Label(index.ToString(), GUILayout.Width(24f));
if (GUILayout.Button(iter.Key, "OL TextField", GUILayout.Height(20f)))
{
selection = 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 (mDelNames.Contains(iter.Key))
{
GUI.backgroundColor = Color.red;
if (GUILayout.Button("Delete", GUILayout.Width(60f)))
{
delete = true;
}
GUI.backgroundColor = Color.green;
if (GUILayout.Button("X", GUILayout.Width(22f)))
{
mDelNames.Remove(iter.Key);
delete = false;
}
GUI.backgroundColor = Color.white;
}
else
{
// If we have not yet selected a sprite for deletion, show a small "X" button
if (GUILayout.Button("X", GUILayout.Width(22f)))
{
mDelNames.Add(iter.Key);
}
}
}
GUILayout.EndHorizontal();
}
GUILayout.EndScrollView();
// If this sprite was marked for deletion, remove it from the atlas
if (delete)
{
List <SpriteEntry> sprites = new List <SpriteEntry>();
ExtractSprites(NGUISettings.atlas, sprites);
for (int i = sprites.Count; i > 0;)
{
SpriteEntry ent = sprites[--i];
if (mDelNames.Contains(ent.name))
{
sprites.RemoveAt(i);
}
}
UpdateAtlas(NGUISettings.atlas, sprites);
mDelNames.Clear();
}
else if (update)
{
UpdateAtlas(textures, true);
}
else if (replace)
{
UpdateAtlas(textures, false);
}
if (NGUISettings.atlas != null && !string.IsNullOrEmpty(selection))
{
NGUISettings.selectedSprite = selection;
Selection.activeGameObject = NGUISettings.atlas.gameObject;
if (UIAtlasInspector.instance != null)
{
UIAtlasInspector.instance.Repaint();
}
}
}
}
public override void OnInspectorGUI()
{
so.Update();
RefreshVars();
EditorGUIUtility.LookLikeControls(135.0f, 50.0f);
for (int i = 0; i < properties.Length; i += 1)
{
InspectorPlusVar v = vars[i];
if (v.active && properties[i] != null)
{
SerializedProperty sp = properties [i]; string s = v.type;
bool skip = false;
name = v.name;
dispName = v.dispName;
GUI.enabled = v.canWrite;
GUILayout.BeginHorizontal();
if (v.toggleLevel != 0)
{
GUILayout.Space(v.toggleLevel * 10.0f);
}
if (s == typeof(float).Name)
{
FloatField(sp, v);
skip = true;
}
if (s == typeof(int).Name)
{
IntField(sp, v);
skip = true;
}
if (s == typeof(bool).Name)
{
i += BoolField(sp, v);
skip = true;
}
if (!skip)
{
PropertyField(sp, name);
}
GUILayout.EndHorizontal();
GUI.enabled = true;
}
}
so.ApplyModifiedProperties();
//NOTE NOTE NOTE: WATERMARK HERE
//You are free to remove this
//START REMOVE HERE
GUILayout.BeginHorizontal();
GUI.color = new Color(1.0f, 1.0f, 1.0f, 0.3f);
GUILayout.FlexibleSpace();
GUILayout.Label("Created with");
GUI.color = new Color(1.0f, 1.0f, 1.0f, 0.6f);
if (GUILayout.Button("Inspector++"))
{
Application.OpenURL("http://forum.unity3d.com/threads/136727-Inspector-Meh-to-WOW-inspectors");
}
GUI.color = new Color(1.0f, 1.0f, 1.0f);
GUILayout.EndHorizontal();
//END REMOVE HERE
}
public override void OnInspectorGUI(NavGraph target)
{
PointGraph graph = target as PointGraph;
/*
#if UNITY_3_3
* graph.root = (Transform)EditorGUILayout.ObjectField (new GUIContent ("Root","All childs of this object will be used as nodes, if it is not set, a tag search will be used instead (see below)"),graph.root,typeof(Transform));
#else
* graph.root = (Transform)EditorGUILayout.ObjectField (new GUIContent ("Root","All childs of this object will be used as nodes, if it is not set, a tag search will be used instead (see below)"),graph.root,typeof(Transform),true);
#endif
*/
//Debug.Log (EditorGUI.indentLevel);
graph.root = ObjectField(new GUIContent("Root", "All childs of this object will be used as nodes, if it is not set, a tag search will be used instead (see below)"), graph.root, typeof(Transform), true) as Transform;
graph.recursive = EditorGUILayout.Toggle(new GUIContent("Recursive", "Should childs of the childs in the root GameObject be searched"), graph.recursive);
graph.searchTag = EditorGUILayout.TagField(new GUIContent("Tag", "If root is not set, all objects with this tag will be used as nodes"), graph.searchTag);
#if UNITY_4
if (graph.root != null)
{
EditorGUILayout.HelpBox("All childs " + (graph.recursive ? "and sub-childs ":"") + "of 'root' will be used as nodes\nSet root to null to use a tag search instead", MessageType.None);
}
else
{
EditorGUILayout.HelpBox("All object with the tag '" + graph.searchTag + "' will be used as nodes" + (graph.searchTag == "Untagged" ? "\nNote: the tag 'Untagged' cannot be used" : ""), MessageType.None);
}
#else
if (graph.root != null)
{
GUILayout.Label("All childs " + (graph.recursive ? "and sub-childs ":"") + "of 'root' will be used as nodes\nSet root to null to use a tag search instead", AstarPathEditor.helpBox);
}
else
{
GUILayout.Label("All object with the tag '" + graph.searchTag + "' will be used as nodes" + (graph.searchTag == "Untagged" ? "\nNote: the tag 'Untagged' cannot be used" : ""), AstarPathEditor.helpBox);
}
#endif
graph.maxDistance = EditorGUILayout.FloatField(new GUIContent("Max Distance", "The max distance in world space for a connection to be valid. A zero counts as infinity"), graph.maxDistance);
#if UNITY_LE_4_3
EditorGUIUtility.LookLikeControls();
#endif
#if UNITY_4
graph.limits = EditorGUILayout.Vector3Field("Max Distance (axis aligned)", graph.limits);
#else
EditorGUILayoutx.BeginIndent();
graph.limits = EditorGUILayout.Vector3Field("Max Distance (axis aligned)", graph.limits);
EditorGUILayoutx.EndIndent();
#endif
#if UNITY_LE_4_3
EditorGUIUtility.LookLikeInspector();
#endif
graph.raycast = EditorGUILayout.Toggle(new GUIContent("Raycast", "Use raycasting to check if connections are valid between each pair of nodes"), graph.raycast);
//EditorGUILayoutx.FadeArea fade = editor.GUILayoutx.BeginFadeArea (graph.raycast,"raycast");
//if ( fade.Show () ) {
if (graph.raycast)
{
EditorGUI.indentLevel++;
graph.thickRaycast = EditorGUILayout.Toggle(new GUIContent("Thick Raycast", "A thick raycast checks along a thick line with radius instead of just along a line"), graph.thickRaycast);
//editor.GUILayoutx.BeginFadeArea (graph.thickRaycast,"thickRaycast");
if (graph.thickRaycast)
{
graph.thickRaycastRadius = EditorGUILayout.FloatField(new GUIContent("Raycast Radius", "The radius in world units for the thick raycast"), graph.thickRaycastRadius);
}
//editor.GUILayoutx.EndFadeArea ();
//graph.mask = 1 << EditorGUILayout.LayerField ("Mask",(int)Mathf.Log (graph.mask,2));
graph.mask = EditorGUILayoutx.LayerMaskField(/*new GUIContent (*/ "Mask" /*,"Used to mask which layers should be checked")*/, graph.mask);
EditorGUI.indentLevel--;
}
//editor.GUILayoutx.EndFadeArea ();
}
//-------------------------------------------------------------------------
void OnGUI()
{
AssetPostprocessorDetectTK2DCommit.TargetColliderGenTK2DWindow = this;
bool isFirstOnGuiCallOfLayoutRenderPair = Event.current.type == EventType.Layout;
if (isFirstOnGuiCallOfLayoutRenderPair)
{
CheckForSelectedSpriteCollectionAndSprites();
CheckForValuesToUpdate();
}
EditorGUIUtility.LookLikeControls(150.0f);
mScrollViewVector = GUILayout.BeginScrollView(mScrollViewVector);
mLiveUpdate = EditorGUILayout.Toggle(mEditorLiveUpdateLabel, mLiveUpdate);
// int [3..100] max point count
mAlgorithmHelper.MaxPointCountOfFirstEnabledRegion = GuiHelper.IntSliderGuiElement(mColliderPointCountLabel, mAlgorithmHelper.MaxPointCountOfFirstEnabledRegion, 3, mPointCountSliderMax, ref mColliderPointCountChanged);
// Note: Removed since it was not intuitive enough to use.
// float [0..max(width, height)] Accepted Distance
//float imageMinExtent = Mathf.Min(targetObject.mTextureWidth, targetObject.mTextureHeight);
//targetObject.mVertexReductionDistanceTolerance = EditorGUILayout.Slider("Accepted Distance", targetObject.mVertexReductionDistanceTolerance, 0.0f, imageMinExtent/2);
// float [0..1] Alpha Opaque Threshold
mAlgorithmHelper.RegionIndependentParams.AlphaOpaqueThreshold = GuiHelper.FloatSliderGuiElement(mAlphaOpaqueThresholdLabel, mAlgorithmHelper.RegionIndependentParams.AlphaOpaqueThreshold, 0.0f, 1.0f, ref mNormalizedAlphaOpaqueThresholdChanged);
mAlgorithmHelper.RegionIndependentParams.Convex = GuiHelper.ToggleGuiElement(mConvexLabel, mAlgorithmHelper.RegionIndependentParams.Convex, ref mConvexChanged);
mAlgorithmHelper.RegionIndependentParams.FlipInsideOutside = GuiHelper.ToggleGuiElement(mFlipInsideOutsideLabel, mAlgorithmHelper.RegionIndependentParams.FlipInsideOutside, ref mFlipInsideOutsideChanged);
// Advanced settings
mShowAdvanced = EditorGUILayout.Foldout(mShowAdvanced, mAdvancedSettingsLabel);
if (mShowAdvanced)
{
EditorGUI.indentLevel++;
mAlgorithmHelper.RegionIndependentParams.CustomTex = (Texture2D)GuiHelper.ObjectFieldGuiElement(mCustomImageLabel, mAlgorithmHelper.RegionIndependentParams.CustomTex, typeof(Texture2D), false, ref mCustomTexChanged);
mAlgorithmHelper.RegionIndependentParams.CustomScale = GuiHelper.Vector2FieldGuiElement(mCustomScaleLabel, mAlgorithmHelper.RegionIndependentParams.CustomScale, ref mCustomScaleChanged);
mAlgorithmHelper.RegionIndependentParams.CustomOffset = GuiHelper.Vector2FieldGuiElement(mCustomOffsetLabel, mAlgorithmHelper.RegionIndependentParams.CustomOffset, ref mCustomOffsetChanged);
EditorGUI.indentLevel--;
}
bool haveColliderRegionEnabledChanged = false;
bool haveColliderRegionMaxPointCountChanged = false;
bool haveColliderRegionConvexChanged = false;
OnInspectorGuiHolesAndIslandsSection(out haveColliderRegionEnabledChanged, out haveColliderRegionMaxPointCountChanged, out haveColliderRegionConvexChanged);
if (GUILayout.Button(mCalculateOutlineVerticesLabel))
{
RecalculateSelectedColliders();
}
GUILayout.EndScrollView();
if (mLiveUpdate && mSpriteCollectionProxyToEdit != null && mSpriteIDsToEdit != null)
{
bool pointCountNeedsUpdate = (mColliderPointCountChanged /*&& (mColliderPointCount > 2)*/); // when typing 28, it would otherwise update at the first digit '2'.
if (pointCountNeedsUpdate ||
mFlipInsideOutsideChanged ||
mConvexChanged ||
mNormalizedAlphaOpaqueThresholdChanged ||
mCustomTexChanged ||
mCustomScaleChanged ||
mCustomOffsetChanged ||
haveColliderRegionEnabledChanged || haveColliderRegionMaxPointCountChanged || haveColliderRegionConvexChanged)
{
RecalculateSelectedColliders();
}
}
}
public override void OnInspectorGUI()
{
EditorGUIUtility.LookLikeControls();
BuildingCreation building_creation = (BuildingCreation)target as BuildingCreation;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.Separator();
EditorGUILayout.Separator();
EditorGUILayout.PrefixLabel("Generate All Buildings");
building_creation.generateAllBuildings = EditorGUILayout.Toggle(building_creation.generateAllBuildings);
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
EditorGUILayout.Separator();
EditorGUILayout.Separator();
EditorGUILayout.BeginHorizontal();
building_creation.buildingsToGenerate = (int)EditorGUILayout.IntSlider("Buildings to Generate", building_creation.buildingsToGenerate, 1, number_of_buildings);
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
EditorGUILayout.Separator();
EditorGUILayout.BeginHorizontal();
building_creation.scalingFactor = (float)EditorGUILayout.Slider("Scaling Factor", building_creation.scalingFactor, 1, 100);
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
EditorGUILayout.Separator();
Rect startButton = EditorGUILayout.BeginHorizontal();
startButton.x = startButton.width / 2 - 100;
startButton.width = 200;
startButton.height = 18;
if (!enter)
{
setNumberOfBuildings();
enter = true;
}
if (GUI.Button(startButton, "Create Buildings"))
{
building_creation.createBuilding();
GUIUtility.ExitGUI();
}
if (GUI.changed)
{
EditorUtility.SetDirty(building_creation);
}
}
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;
}
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;
}
}
}
public override void OnInspectorGUI()
{
this.m_Target = (PhotonView)target;
bool isProjectPrefab = EditorUtility.IsPersistent(this.m_Target.gameObject);
if (this.m_Target.ObservedComponents == null)
{
this.m_Target.ObservedComponents = new System.Collections.Generic.List <Component>();
}
if (this.m_Target.ObservedComponents.Count == 0)
{
this.m_Target.ObservedComponents.Add(null);
}
EditorGUILayout.BeginHorizontal();
// Owner
if (isProjectPrefab)
{
EditorGUILayout.LabelField("Owner:", "Set at runtime");
}
else if (!this.m_Target.isOwnerActive)
{
EditorGUILayout.LabelField("Owner", "Scene");
}
else
{
PhotonPlayer owner = this.m_Target.owner;
string ownerInfo = (owner != null) ? owner.NickName : "<no PhotonPlayer found>";
if (string.IsNullOrEmpty(ownerInfo))
{
ownerInfo = "<no playername set>";
}
EditorGUILayout.LabelField("Owner", "[" + this.m_Target.ownerId + "] " + ownerInfo);
}
// ownership requests
EditorGUI.BeginDisabledGroup(Application.isPlaying);
OwnershipOption own = (OwnershipOption)EditorGUILayout.EnumPopup(this.m_Target.ownershipTransfer, GUILayout.Width(100));
if (own != this.m_Target.ownershipTransfer)
{
// jf: fixed 5 and up prefab not accepting changes if you quit Unity straight after change.
// not touching the define nor the rest of the code to avoid bringing more problem than solving.
EditorUtility.SetDirty(this.m_Target);
Undo.RecordObject(this.m_Target, "Change PhotonView Ownership Transfer");
this.m_Target.ownershipTransfer = own;
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndHorizontal();
// View ID
if (isProjectPrefab)
{
EditorGUILayout.LabelField("View ID", "Set at runtime");
}
else if (EditorApplication.isPlaying)
{
EditorGUILayout.LabelField("View ID", this.m_Target.viewID.ToString());
}
else
{
int idValue = EditorGUILayout.IntField("View ID [1.." + (PhotonNetworkManager.MAX_VIEW_IDS - 1) + "]", this.m_Target.viewID);
if (this.m_Target.viewID != idValue)
{
Undo.RecordObject(this.m_Target, "Change PhotonView viewID");
this.m_Target.viewID = idValue;
}
}
// Locally Controlled
if (EditorApplication.isPlaying)
{
string masterClientHint = PhotonNetworkManager.isMasterClient ? "(master)" : "";
EditorGUILayout.Toggle("Controlled locally: " + masterClientHint, this.m_Target.isMine);
}
// ViewSynchronization (reliability)
if (this.m_Target.synchronization == ViewSynchronization.Off)
{
GUI.color = Color.grey;
}
EditorGUILayout.PropertyField(serializedObject.FindProperty("synchronization"), new GUIContent("Observe option:"));
if (this.m_Target.synchronization != ViewSynchronization.Off && this.m_Target.ObservedComponents.FindAll(item => item != null).Count == 0)
{
GUILayout.BeginVertical(GUI.skin.box);
GUILayout.Label("Warning", EditorStyles.boldLabel);
GUILayout.Label("Setting the synchronization option only makes sense if you observe something.");
GUILayout.EndVertical();
}
DrawSpecificTypeSerializationOptions();
GUI.color = Color.white;
DrawObservedComponentsList();
// Cleanup: save and fix look
if (GUI.changed)
{
#if !UNITY_MIN_5_3
EditorUtility.SetDirty(this.m_Target);
#endif
PhotonViewHandler.HierarchyChange(); // TODO: check if needed
}
GUI.color = Color.white;
#if !UNITY_MIN_5_3
EditorGUIUtility.LookLikeControls();
#endif
}
public override void OnInspectorGUI()
{
serializedObject.Update();
bool changeOccurred = false;
EditorGUIUtility.LookLikeControls(180);
tk2dUIItem btn = (tk2dUIItem)target;
bool newIsChildOfAnotherMenuBtn = EditorGUILayout.Toggle("Child of Another UIItem?", btn.InternalGetIsChildOfAnotherUIItem());
if (newIsChildOfAnotherMenuBtn != btn.InternalGetIsChildOfAnotherUIItem())
{
changeOccurred = true;
btn.InternalSetIsChildOfAnotherUIItem(newIsChildOfAnotherMenuBtn);
}
btn.registerPressFromChildren = EditorGUILayout.Toggle("Register Events From Children", btn.registerPressFromChildren);
btn.isHoverEnabled = EditorGUILayout.Toggle("Is Hover Events Enabled?", btn.isHoverEnabled);
GUILayout.Label("Send Message", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
GameObject newSendMessageTarget = EditorGUILayout.ObjectField("Target", btn.sendMessageTarget, typeof(GameObject), true, null) as GameObject;
if (newSendMessageTarget != btn.sendMessageTarget)
{
changeOccurred = true;
btn.sendMessageTarget = newSendMessageTarget;
}
if (btn.sendMessageTarget != null && EditorUtility.IsPersistent(btn.sendMessageTarget))
{
changeOccurred = true;
btn.sendMessageTarget = null;
}
if (btn.sendMessageTarget != null)
{
btn.SendMessageOnDownMethodName = EditorGUILayout.TextField("On Down Method Name", btn.SendMessageOnDownMethodName);
btn.SendMessageOnUpMethodName = EditorGUILayout.TextField("On Up Method Name", btn.SendMessageOnUpMethodName);
btn.SendMessageOnClickMethodName = EditorGUILayout.TextField("On Clicked Method Name", btn.SendMessageOnClickMethodName);
btn.SendMessageOnReleaseMethodName = EditorGUILayout.TextField("On Release Method Name", btn.SendMessageOnReleaseMethodName);
}
EditorGUI.indentLevel--;
if (btn.GetComponent <Collider>() != null)
{
GUILayout.Label("Collider", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
GUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Automatic Fit");
if (GUILayout.Button("Fit", GUILayout.MaxWidth(100)))
{
tk2dUIItemBoundsHelper.FixColliderBounds(btn);
}
GUILayout.EndHorizontal();
ArrayProperty("Extra Bounds", extraBoundsProp);
ArrayProperty("Ignore Bounds", ignoreBoundsProp);
EditorGUI.indentLevel--;
}
serializedObject.ApplyModifiedProperties();
if (GUI.changed || changeOccurred)
{
EditorUtility.SetDirty(btn);
}
}
/// <summary>
/// Draw the inspector.
/// </summary>
public override void OnInspectorGUI()
{
#if UNITY_4_3
EditorGUIUtility.LookLikeControls(130f);
#else
EditorGUIUtility.labelWidth = 130f;
#endif
m = target as NJGMapZone;
NJGEditorTools.DrawEditMap();
GUILayout.BeginHorizontal("AppToolbar");
EditorGUILayout.LabelField(new GUIContent("Zone Name Preview", ""), GUILayout.Width(130f));
GUI.contentColor = m.color;
EditorGUILayout.LabelField(new GUIContent(m.zone, ""), EditorStyles.boldLabel);
GUI.contentColor = Color.white;
GUILayout.EndHorizontal();
string level = NJGEditorTools.DrawList("Level", NJGMapBase.instance.GetLevels(), m.level);
string zone = NJGEditorTools.DrawList("Zone", NJGMapBase.instance.GetZones(m.level), m.zone);
string triggerTag = EditorGUILayout.TagField("Trigger Tag", m.triggerTag);
int colliderRadius = (int)EditorGUILayout.Slider("Collider Radius", m.colliderRadius, 1, 1000);
bool generateOnTrigger = EditorGUILayout.Toggle("Generate On Trigger", m.generateOnTrigger);
string name = "Zone - [" + NJGMapZone.list.IndexOf(m) + "] " + m.zone;
if (m.name != name ||
m.level != level ||
m.zone != zone ||
m.triggerTag != triggerTag ||
m.colliderRadius != colliderRadius ||
m.generateOnTrigger != generateOnTrigger)
{
m.name = name;
m.level = level;
m.zone = zone;
m.triggerTag = triggerTag;
m.colliderRadius = colliderRadius;
m.zoneCollider.radius = colliderRadius;
m.generateOnTrigger = generateOnTrigger;
NJGEditorTools.RegisterUndo("NJG Zone Update", m);
}
/*if (NJGMapBase.instance != null)
* {
* if (NJGMapBase.instance.atlas != null)
* {
* extraSpace = Mathf.Max(0f, extraSpace - 30f);
* }
* }*/
NJGEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
GUI.backgroundColor = Color.green;
if (GUILayout.Button("Add New Zone"))
{
NJGMenu.AddMapZone();
}
GUI.backgroundColor = Color.white;
GUI.backgroundColor = Color.red;
if (GUILayout.Button("Delete Zone"))
{
Delete();
}
GUI.backgroundColor = Color.white;
GUILayout.EndHorizontal();
EditorGUILayout.Separator();
}
/// <summary>
/// Draw the custom wizard.
/// </summary>
void OnGUI()
{
// Load the saved preferences
if (!mLoaded)
{
mLoaded = true; Load();
}
EditorGUIUtility.LookLikeControls(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, 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;
}
}
}
private void DrawConditionsHeader(Rect headerRect)
{
EditorGUIUtility.LookLikeControls();
GUI.Label(headerRect, new GUIContent("Conditions"));
}
