Exemple #1
0
        public static object DeformableTerrainShovelExcavationSettingsDrawer(object[] objects, InvokeWrapper wrapper)
        {
            var data = new ExcavationSettingsResult()
            {
                Value = wrapper.Get <DeformableTerrainShovelSettings.ExcavationSettings>(objects[0])
            };

            if (InspectorGUI.Foldout(EditorData.Instance.GetData(objects[0] as Object, wrapper.Member.Name),
                                     InspectorGUI.MakeLabel(wrapper.Member)))
            {
                using (InspectorGUI.IndentScope.Single) {
                    data.Value.Enabled = InspectorGUI.Toggle(GUI.MakeLabel("Enabled"),
                                                             data.Value.Enabled);
                    data.EnabledChanged                 = UnityEngine.GUI.changed;
                    UnityEngine.GUI.changed             = false;
                    data.Value.CreateDynamicMassEnabled = InspectorGUI.Toggle(GUI.MakeLabel("Create Dynamic Mass Enabled"),
                                                                              data.Value.CreateDynamicMassEnabled);
                    data.CreateDynamicMassEnabledChanged = UnityEngine.GUI.changed;
                    UnityEngine.GUI.changed         = false;
                    data.Value.ForceFeedbackEnabled = InspectorGUI.Toggle(GUI.MakeLabel("Force Feedback Enabled"),
                                                                          data.Value.ForceFeedbackEnabled);
                    data.ForceFeedbackEnabledChanged = UnityEngine.GUI.changed;
                    UnityEngine.GUI.changed          = false;
                }
                UnityEngine.GUI.changed = data.ContainsChanges;
            }
            return(data);
        }
Exemple #2
0
        public static void DrawUrdfMaterial(AGXUnity.IO.URDF.Material material)
        {
            // Name has already been rendered.
            InspectorGUI.Toggle(GUI.MakeLabel("Is Reference"), material.IsReference);
            if (material.IsReference)
            {
                return;
            }
            var colorRect = EditorGUILayout.GetControlRect();

            EditorGUI.PrefixLabel(colorRect, GUI.MakeLabel("Color"));
            var oldXMax = colorRect.xMax;

            colorRect.x   += EditorGUIUtility.labelWidth;
            colorRect.xMax = oldXMax;
            EditorGUI.DrawRect(colorRect, material.Color);
        }
Exemple #3
0
        public void OnInspectorGUI()
        {
            var skin = InspectorEditor.Skin;

            using (GUI.AlignBlock.Center)
                GUILayout.Label(GUI.MakeLabel("AGXUnity Editor Settings", 24, true), skin.Label);

            BuildPlayer_CopyBinaries = InspectorGUI.Toggle(GUI.MakeLabel("<b>Build:</b> Copy AGX Dynamics binaries",
                                                                         false,
                                                                         "[Recommended enabled]\nCopy dependent AGX Dynamics binaries to target player directory."),
                                                           BuildPlayer_CopyBinaries);
            AGXDynamics_LogPath = InspectorGUI.ToggleSaveFile(GUI.MakeLabel("AGX Dynamics log"),
                                                              AGXDynamics_LogEnabled,
                                                              enable => AGXDynamics_LogEnabled = enable,
                                                              AGXDynamics_LogPath,
                                                              "AGXDynamicsLog",
                                                              "txt",
                                                              "AGX Dynamics log filename",
                                                              extension => true);

            if (ExternalAGXInitializer.IsApplied)
            {
                DirectoryInfo newAgxDir = null;
                if (InspectorGUI.SelectFolder(GUI.MakeLabel("AGX Dynamics directory"),
                                              ExternalAGXInitializer.Instance.AGX_DIR,
                                              "AGX Dynamics directory",
                                              newFolder => newAgxDir = new DirectoryInfo(newFolder)))
                {
                    if (ExternalAGXInitializer.FindType(newAgxDir) == ExternalAGXInitializer.AGXDirectoryType.Unknown)
                    {
                        Debug.LogError($"ERROR: {newAgxDir.FullName} doesn't seems to be an AGX Dynamics root folder.");
                    }
                    else if (EditorUtility.DisplayDialog("Change AGX Dynamics directory",
                                                         $"Change from {ExternalAGXInitializer.Instance.AGX_DIR} to {newAgxDir.FullName}?\n\n" +
                                                         "Unity will restart during the change.",
                                                         "Yes",
                                                         "Cancel"))
                    {
                        ExternalAGXInitializer.ChangeRootDirectory(newAgxDir);
                    }
                }
            }
            else if (!IO.Utils.AGXDynamicsInstalledInProject && ExternalAGXInitializer.UserSaidNo)
            {
                var rect     = EditorGUILayout.GetControlRect();
                var orgWidth = rect.width;
                rect.width = EditorGUIUtility.labelWidth;
                EditorGUI.PrefixLabel(rect, GUI.MakeLabel("Select AGX Dynamics root folder"), skin.Label);
                rect.x    += rect.width;
                rect.width = orgWidth - EditorGUIUtility.labelWidth;
                if (UnityEngine.GUI.Button(rect, GUI.MakeLabel("AGX Dynamics root directory...")))
                {
                    var agxDir = EditorUtility.OpenFolderPanel("AGX Dynamics root directory",
                                                               "Assets",
                                                               "");
                    if (!string.IsNullOrEmpty(agxDir))
                    {
                        var agxDirInfo = new DirectoryInfo(agxDir);
                        var type       = ExternalAGXInitializer.FindType(agxDirInfo);
                        if (type == ExternalAGXInitializer.AGXDirectoryType.Unknown)
                        {
                            Debug.LogWarning($"{agxDir} isn't recognized as an AGX Dynamics root directory.");
                        }
                        else if (EditorUtility.DisplayDialog("Add AGX Dynamics directory",
                                                             $"Set AGX Dynamics root directory to {agxDir}?\n\n" +
                                                             "Unity will restart during the process.",
                                                             "Yes",
                                                             "Cancel"))
                        {
                            ExternalAGXInitializer.UserSaidNo = false;
                            ExternalAGXInitializer.ChangeRootDirectory(agxDirInfo);
                        }
                    }
                }
            }

            InspectorGUI.Separator(1, 4);

            // BuiltInToolsTool settings GUI.
            {
                HandleKeyHandlerGUI(GUI.MakeLabel("Select game object"), BuiltInToolsTool_SelectGameObjectKeyHandler);
                HandleKeyHandlerGUI(GUI.MakeLabel("Select rigid body game object"), BuiltInToolsTool_SelectRigidBodyKeyHandler);
                HandleKeyHandlerGUI(GUI.MakeLabel("Pick handler (scene view)"), BuiltInToolsTool_PickHandlerKeyHandler);
            }
        }
Exemple #4
0
 public static object BoolDrawer(object[] objects, InvokeWrapper wrapper)
 {
     return(InspectorGUI.Toggle(InspectorGUI.MakeLabel(wrapper.Member),
                                wrapper.Get <bool>(objects[0])));
 }
Exemple #5
0
        private void HandleKeyHandlerGUI(GUIContent name, Utils.KeyHandler keyHandler)
        {
            const int keyButtonWidth      = 90;
            var       showDropdownPressed = false;

            GUILayout.BeginHorizontal();
            {
                keyHandler.Enable = InspectorGUI.Toggle(name, keyHandler.Enable);
                GUILayout.FlexibleSpace();

                UnityEngine.GUI.enabled = keyHandler.Enable;

                for (int iKey = 0; iKey < keyHandler.NumKeyCodes; ++iKey)
                {
                    GUIContent buttonLabel = keyHandler.IsDetectingKey(iKey) ?
                                             GUI.MakeLabel("Detecting...") :
                                             GUI.MakeLabel(keyHandler.Keys[iKey].ToString());

                    bool toggleDetecting = GUILayout.Button(buttonLabel,
                                                            InspectorEditor.Skin.ButtonMiddle,
                                                            GUILayout.Width(keyButtonWidth),
                                                            GUILayout.Height(ToggleButtonSize));
                    if (toggleDetecting)
                    {
                        keyHandler.DetectKey(this, !keyHandler.IsDetectingKey(iKey), iKey);
                    }
                }

                GUILayout.BeginVertical(GUILayout.Height(ToggleButtonSize));
                {
                    GUIStyle tmp = new GUIStyle(InspectorEditor.Skin.Button);
                    tmp.fontSize = 6;

                    showDropdownPressed = InspectorGUI.Button(MiscIcon.ContextDropdown,
                                                              true,
                                                              "Add or remove key or reset key to default.",
                                                              GUILayout.Width(16));
                    GUILayout.FlexibleSpace();
                }
                GUILayout.EndVertical();

                UnityEngine.GUI.enabled = true;

                if (showDropdownPressed)
                {
                    GenericMenu menu = new GenericMenu();
                    menu.AddItem(GUI.MakeLabel("Reset to default"), false, () =>
                    {
                        if (EditorUtility.DisplayDialog("Reset to default", "Reset key(s) to default?", "OK", "Cancel"))
                        {
                            keyHandler.ResetToDefault();
                        }
                    });
                    menu.AddItem(GUI.MakeLabel("Add key"), false, () =>
                    {
                        keyHandler.Add(KeyCode.None);
                    });

                    if (keyHandler.NumKeyCodes > 1)
                    {
                        menu.AddItem(GUI.MakeLabel("Remove key"), false, () =>
                        {
                            if (EditorUtility.DisplayDialog("Remove key", "Remove key: " + keyHandler[keyHandler.NumKeyCodes - 1].ToString() + "?", "OK", "Cancel"))
                            {
                                keyHandler.Remove(keyHandler.NumKeyCodes - 1);
                            }
                        });
                    }

                    menu.ShowAsContext();
                }
            }
            GUILayout.EndHorizontal();

            if (UnityEngine.GUI.changed)
            {
                EditorUtility.SetDirty(this);
            }
        }