/// <summary> /// A method that allows us to draw our modified NGUITransformInspector, if the user wants to. /// </summary> void DrawNGUI() { //Get the type via reflection var NGUI = TransformInspectorUtility.GetType("NGUITransformInspector"); //Get the DrawInspector method MethodInfo NGUI_DrawInspector = NGUI.GetMethod("DrawInspector"); //Get the OnEnable method MethodInfo NGUI_OnEnable = NGUI.GetMethod("OnEnable"); //Create an instance of the NGUITransformInspector class var NGUIObject = Activator.CreateInstance(NGUI); //If we found the method (not null)... if (NGUI_OnEnable != null) { NGUI_OnEnable.Invoke(NGUIObject, new object[] { this.serializedObject }); } else //Otherwise, something horrible has gone wrong, so put an error in the console. { Debug.LogError("Catastrophic reflection failure! Contact U2DEX support!"); } //If we found the method (not null)... if (NGUI_DrawInspector != null) { NGUI_DrawInspector.Invoke(NGUIObject, null); } else //Otherwise, something horrible has gone wrong, so put an error in the console. { Debug.LogError("Catastrophic reflection failure! Contact U2DEX support!"); } }
/// <summary> /// A method that returns whether the user has NGUI installed. /// </summary> /// <returns></returns> bool FoundNGUI() { var NGUI = TransformInspectorUtility.GetType("NGUITransformInspector"); if (NGUI != null) { return(true); } return(false); }
/// <summary> /// The OnGUI function for this Editor Window. Handles all the GUI drawing. /// </summary> private static void OnGUI(bool DrawTitles) { labelStyle = new GUIStyle(GUI.skin.label); labelStyle.padding.top = 0; labelStyle.padding.left = 0; if (DrawTitles) { GUILayout.Label("Grid Preferences", EditorStyles.boldLabel, new GUILayoutOption[0]); } DrawGridOptions(340); if (DrawTitles) { GUILayout.Label("Snapping Preferences", EditorStyles.boldLabel, new GUILayoutOption[0]); } DrawSnapOptions(340); GUILayout.Space(10); if (DrawTitles) { GUILayout.Label("2D Transform Inspector", EditorStyles.boldLabel, new GUILayoutOption[0]); } DisplayPluginToggle(); DrawApplicableClassesOptions(345); //Only draw this if we've found NGUI, and it's our modified NGUITransformInspector if (TransformInspectorUtility.GetType("NGUITransformInspector") != null && TransformInspectorUtility.GetType("NGUITransformInspector").GetMethod("DrawInspector") != null) { GUILayout.Space(10); if (DrawTitles) { GUILayout.Label("Third-party Compatibility and Support", EditorStyles.boldLabel, new GUILayoutOption[0]); } DisplayThirdPartySupport(); } else if (TransformInspectorUtility.GetType("NGUITransformInspector") != null) { //Otherwise, if we found an unaltered NGUITransformInspector, let the user know about it via a warning. GUILayout.Space(10); EditorGUILayout.HelpBox("NGUI has been detected.\nIf you want to use U2DEX's Transform Inspector" + " instead of NGUI's, please import the NGUISupport.unitypackage found" + " in the root U2DEX folder." + "\n\nYou can then toggle between the two inspectors here.", MessageType.Warning); } //GUILayout.Space(10); //We don't need a space here -- it's already 'added' by the bottom of the ScrollView if (DrawTitles) { GUILayout.Label("Help and Updates", EditorStyles.boldLabel, new GUILayoutOption[0]); } DisplayHelpAndUpdates(340); GUILayout.Space(10); }
private static void DrawApplicableClassesOptions(int Width) { // Use a Horizontal space or the toolbar will extend to the left no matter what EditorGUILayout.BeginHorizontal(GUILayout.Width(Width)); EditorGUILayout.BeginHorizontal(EditorStyles.toolbar); if (GlobalSnappingData.ApplicableClasses.Count > 0) { GUIContent content; GUIStyle iconStyle; iconStyle = new GUIStyle(EditorStyles.toolbarButton); //use a different font size for each icon, since they're not the same size... if (hide) { iconStyle.fontSize = 15; } else { iconStyle.fontSize = 10; } var icon = (hide == true) ? "\u25B6" : "\u25BC"; var tooltip = (hide == true) ? "Click to show all" : "Click to hide all"; content = new GUIContent(icon, tooltip); //If the button if pressed, toggle the hide boolean. if (GUILayout.Button(content, iconStyle, GUILayout.Width(25))) { //Hide equals the opposite of Hide... hide = !hide; } } EditorGUILayout.LabelField("Applicable Classes", labelStyle); //Add the + button... EditorGUILayout.BeginHorizontal(GUILayout.MaxWidth(75)); GUIStyle style = new GUIStyle(EditorStyles.toolbarButton); style.fontSize = 16; style.padding.bottom = 2; //Add button if (GUILayout.Button(new GUIContent("+", "Click to add a class"), style)) { GlobalSnappingData.ApplicableClasses.Add("Give me a class name!"); //if we're hiding the entries, unhide them since we just added one. if (hide) { hide = false; } } //switch the font size and padding for this button... style.padding.bottom = 1; style.fontSize = 10; //Help button if (GUILayout.Button(new GUIContent("?", "Click to view help"), style, GUILayout.Width(23))) { //Open a new window instance, or focus on the old one, if we have one open. var help_Window = (AdvancedSnapping_HelpUI)EditorWindow.GetWindow(typeof(AdvancedSnapping_HelpUI), true, u2dexInfo.FullName + ": Snap Tool Help"); /*Let's take a minute to reflect, and get the Preferences window...*/ //Get the assembly... var assembly = System.Reflection.Assembly.GetAssembly(typeof(EditorWindow)); //Get the type... var type = assembly.GetType("UnityEditor.PreferencesWindow"); //Finally, get the preference window from the newly-reflected private type. var preference_Window = EditorWindow.GetWindow(type); //Now, use the preference window's position. Rect position = preference_Window.position; //Position the help window on top of the current window, in a cascading, slightly-offset manner... help_Window.position = new Rect(position.xMin + 200, position.yMin + 100, position.width, position.height); help_Window.Init(); help_Window.minSize = new Vector2(500, 300); help_Window.maxSize = new Vector2(500, 300); //Put the help window in focus... help_Window.Focus(); } //switch it back for any buttons after this... style.padding.bottom = 2; style.fontSize = 16; GUILayout.Space(1); EditorGUILayout.EndHorizontal(); EditorGUILayout.EndHorizontal(); EditorGUILayout.EndHorizontal(); //Keep these outside the !hide if, so the toggle button at the bottom stays at the bottom. EditorGUILayout.BeginVertical(GUILayout.Width(Width)); //Start the ScrollView, but also cap it's height at between 75 and 100 (otherwise it takes up all the space it can...) //We also use fancy single-line evaluation statements to check if we're supposed to hide the list. If we are //hiding the list, we remove the height settings (set to zero) so we don't take up a ton of empty room. scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition, GUILayout.MinHeight(hide ? 0 : 75), GUILayout.MaxHeight(hide ? 0 : 100)); if (!hide) { //center the remove buttons... GUIStyle removeStyle = new GUIStyle(style); removeStyle.margin.top = 1; removeStyle.padding = new RectOffset(2, 2, 0, 2); for (int i = 0; i < GlobalSnappingData.ApplicableClasses.Count; i++) { //Cache whether or not the current class is disabled. var currentClassDisabled = GlobalSnappingData.DisabledClasses.Contains(GlobalSnappingData.ApplicableClasses[i]); //If the current class is disabled, disable our GUI for our first few controls. if (currentClassDisabled) { GUI.enabled = false; } EditorGUILayout.BeginHorizontal(); { Type objectType = null; if (GlobalSnappingData.ApplicableClasses[i] != string.Empty) { objectType = TransformInspectorUtility.GetType(GlobalSnappingData.ApplicableClasses[i]); //Debug.Log(objectType); //BEWARE! Massive performance hit! Only use for debugging. } GUIContent verifyContent; if (objectType != null) { verifyContent = new GUIContent(UnfinityGUIUtil.CheckMark, "This class has been found"); EditorGUILayout.LabelField(verifyContent, verifiedTextStyle, GUILayout.Width(25)); } else { verifyContent = new GUIContent(UnfinityGUIUtil.XMark, "This class cannot be found"); EditorGUILayout.LabelField(verifyContent, unverifiedTextStyle, GUILayout.Width(25)); } EditorGUILayout.LabelField(GetClassStringFromIndex(i), GUILayout.Width(100)); //We only need to check if our class is a supported class if our current class is NOT already disabled. if (!currentClassDisabled) { //Set the enabled field of the GUI to the opposite of whether the class is //officially supported or not. Essentially, if it IS supported, disable the GUI, etc. GUI.enabled = !IsSupportedClass(GlobalSnappingData.ApplicableClasses[i]); } GlobalSnappingData.ApplicableClasses[i] = EditorGUILayout.TextField(GlobalSnappingData.ApplicableClasses[i]); //Add the toggle and x (remove) button... EditorGUILayout.BeginHorizontal(GUILayout.MaxWidth(20)); { //We have to make sure that GUI is enabled for our toggles, so we'll cache the current value //so we can reset it when we're done. var currentGUIEnabled = GUI.enabled; GUI.enabled = true; //Create a variable to house whether or not the current class is enabled. var classEnabled = true; //If the current class is disabled, we'll set our classEnabled flag to false. if (currentClassDisabled) { classEnabled = false; } //Create a variable to house our previous enabled flag, as the toggle may change it. var previousToggleValue = classEnabled; //Create a GUIContent to house our toggle tooltip (that changes depending on the status of classEnabled). GUIContent classToggleContent = new GUIContent("", (classEnabled) ? "Click to disable" : "Click to enable"); //Render our toggle. classEnabled = GUILayout.Toggle(classEnabled, classToggleContent, GUILayout.Width(10)); //If the value changed... if (previousToggleValue != classEnabled) { if (classEnabled) { //If our current class was disabled (but isn't anymore), remove it from our DisabledClasses list. if (currentClassDisabled) { GlobalSnappingData.DisabledClasses.Remove(GlobalSnappingData.ApplicableClasses[i]); } } else { //If our current class wasn't disabled (but it is now), add it to our DisabledClasses list. if (!currentClassDisabled) { GlobalSnappingData.DisabledClasses.Add(GlobalSnappingData.ApplicableClasses[i]); } } } GUILayout.Space(3); //Reset our GUI.enabled flag for the rest of our GUI. GUI.enabled = currentGUIEnabled; //Add button if (GUILayout.Button(new GUIContent("×", "Click to remove this class"), removeStyle)) { GlobalSnappingData.ApplicableClasses.Remove(GlobalSnappingData.ApplicableClasses[i]); } GUILayout.Space(3); } EditorGUILayout.EndHorizontal(); } EditorGUILayout.EndHorizontal(); //if the GUI was disabled, enable it here. if (!GUI.enabled) { GUI.enabled = true; } } } EditorGUILayout.EndScrollView(); EditorGUILayout.EndVertical(); }
public void DrawInspector(Transform target) { Transform t = (Transform)target; //if we're only editing 1 object, otherwise we need to display an error message since multi-object //editing isn't currently supported by this extension. if (Selection.transforms.Length < 2) { // Replicate the standard transform inspector gui if the component isn't part of 2DToolkit if (t.gameObject.GetComponent("tk2dBaseSprite")) { var tk2dSpriteType = TransformInspectorUtility.GetType("tk2dBaseSprite"); var tk2dSprite = t.gameObject.GetComponent("tk2dBaseSprite"); //Get the sprite definition, so we can make sure it isn't null before preceding. MethodInfo tk2d_GetCurrentSpriteDef = tk2dSpriteType.GetMethod("GetCurrentSpriteDef", Type.EmptyTypes); object SpriteDef = tk2d_GetCurrentSpriteDef.Invoke(tk2dSprite, tk2d_GetCurrentSpriteDef.GetParameters()); //Try to check if the 2DToolkit sprite object is valid if (tk2dSprite != null && SpriteDef != null) { DrawSnappingFoldout(t); UnfinityGUIUtil.Unity4Space(); //We only need 2 vectors (X and Y) for 2DToolkit. No need to show the Z value. Vector3 position = EditorGUILayout.Vector2Field("Position", new Vector2(t.localPosition.x, t.localPosition.y)); UnfinityGUIUtil.Unity4Space(); //Again, we only need X and Y for scale. Vector2 scale = EditorGUILayout.Vector2Field("Size", new Vector2(TransformInspectorUtility.GetScaleFromClassName("tk2dBaseSprite", "scale", t).x, TransformInspectorUtility.GetScaleFromClassName("tk2dBaseSprite", "scale", t).y)); UnfinityGUIUtil.Unity4Space(); DrawRotationControls(t); //Leave some vertical space between areas! UnfinityGUIUtil.Unity4Space(); DrawLayerAndDepthControls(t); //allow the Z Depth to be set position.z = (float)EditorGUILayout.IntField("Z Depth", (int)t.localPosition.z); EditorGUI.indentLevel = 0; //Leave some vertical space between areas! EditorGUILayout.Space(); if (GUI.changed) { Undo.RecordObject(t, "Transform Change"); t.localPosition = this.FixIfNaN(position); t.localEulerAngles = this.FixIfNaN(EulerAngles); //Check if the scale is NaN var tk2DScale = new Vector3(scale.x, scale.y, 1); tk2DScale = this.FixIfNaN(tk2DScale); //Then copy it back //tk2dSprite.scale = new Vector2(tk2DScale.x, tk2DScale.y); TransformInspectorUtility.SetScaleFromClassName("tk2dBaseSprite", "scale", t, tk2DScale); //Retrieve the layer by name, and then set it. tk2dSprite.gameObject.layer = LayerMask.NameToLayer(GetSortedLayer()); //copy our changed sprite back to our target. EditorUtility.SetDirty(tk2dSprite); } } } } else { EditorGUILayout.LabelField("Multi-object editing is not supported at this time."); } }
public override void OnInspectorGUI() { Transform t = (Transform)this.target; ObjectType = TransformInspectorUtility.GetObjectType(t); if (!FoundNGUI() || !GlobalSnappingData.UseNGUIInspector) { //if we don't get any supported 2D object types, or we're disabled (either globally, or this particular class type is disabled)... if (ObjectType == null || !GlobalSnappingData.TransformInspectorEnabled || (GlobalSnappingData.DisabledClasses.Contains(ObjectType.Name) || GlobalSnappingData.DisabledClasses.Contains(ObjectType.FullName))) { //This is not an applicable object. GlobalSnappingData.ApplicableObjectSelected = false; //Draw the default inspector DefaultTransformInspector.Draw(t); } else //we got at least one supported 2D object type, find out which one it is. { //This *is* an applicable object. GlobalSnappingData.ApplicableObjectSelected = true; if (ObjectType == TransformInspectorUtility.GetType("tk2dBaseSprite")) { //We got 2D Toolkit, show its inspector. tk2dInspector.DrawInspector(t); } else { //We got Orthello, show its inspector if (ObjectType == TransformInspectorUtility.GetType("OTSprite")) { orthelloInspector.DrawInspector(t); } else { //We got a Unity sprite, show its inspector if (ObjectType == TransformInspectorUtility.GetType("SpriteRenderer")) { unitySpriteInspector.DrawInspector(t); } else { //add more supported 2D stuff here... //The foreach should be in the LAST else bracket, since we want to check for officially supported //types BEFORE types the user entered manually... foreach (string Name in GlobalSnappingData.ApplicableClasses) { //Debug.Log(ObjectType.Name + " == " + Name); //Debug.Log(ObjectType.FullName + " == " + Name); //Make sure that our ObjectType's Name or FullName match our provided name before proceeding. if (ObjectType.Name == Name || ObjectType.FullName == Name) { genericInspector.DrawInspector(t); } } } } } } } else { DrawNGUI(); } }