コード例 #1
0
    private static void inspectFont(dfRichTextLabel control)
    {
        dfPrefabSelectionDialog.SelectionCallback selectionCallback = delegate(GameObject item)
        {
            var font = (item == null) ? null : item.GetComponent <dfDynamicFont>();
            dfEditorUtil.MarkUndo(control, "Assign Dynamic Font");
            control.Font = font;
        };

        var value = control.Font;

        EditorGUILayout.BeginHorizontal();
        {
            EditorGUILayout.LabelField("Default Font", "", GUILayout.Width(dfEditorUtil.LabelWidth));

            var displayText = value == null ? "[none]" : value.name;
            GUILayout.Label(displayText, "TextField");

            var evt = Event.current;
            if (evt != null)
            {
                Rect textRect = GUILayoutUtility.GetLastRect();
                if (evt.type == EventType.mouseDown && evt.clickCount == 2)
                {
                    if (textRect.Contains(evt.mousePosition))
                    {
                        if (GUI.enabled && value != null)
                        {
                            Selection.activeObject = value;
                            EditorGUIUtility.PingObject(value);
                        }
                    }
                }
                else if (evt.type == EventType.DragUpdated || evt.type == EventType.DragPerform)
                {
                    if (textRect.Contains(evt.mousePosition))
                    {
                        var draggedObject = DragAndDrop.objectReferences.First() as GameObject;
                        var draggedFont   = draggedObject != null?draggedObject.GetComponent <dfDynamicFont>() : null;

                        DragAndDrop.visualMode = (draggedFont != null) ? DragAndDropVisualMode.Copy : DragAndDropVisualMode.None;
                        if (evt.type == EventType.DragPerform)
                        {
                            selectionCallback(draggedObject);
                        }
                        evt.Use();
                    }
                }
            }

            if (GUI.enabled && GUILayout.Button(new GUIContent(" ", "Select Font"), "IN ObjectField", GUILayout.Width(14)))
            {
                dfEditorUtil.DelayedInvoke((System.Action)(() =>
                {
                    var dialog         = dfPrefabSelectionDialog.Show("Select Dynamic Font", typeof(dfDynamicFont), selectionCallback, dfFontDefinitionInspector.DrawFontPreview, null);
                    dialog.previewSize = 200;
                }));
            }
        }
        EditorGUILayout.EndHorizontal();

        GUILayout.Space(2);
    }
コード例 #2
0
        private void DrawInputsStage()
        {
            if (DialogueManager.instance.displaySettings.inputSettings == null)
            {
                DialogueManager.instance.displaySettings.inputSettings = new DisplaySettings.InputSettings();
            }
            EditorGUILayout.LabelField("Input Settings", EditorStyles.boldLabel);
            EditorWindowTools.StartIndentedSection();
            EditorGUILayout.HelpBox("In this section, you'll specify input settings for the dialogue UI.", MessageType.Info);
            EditorWindowTools.StartIndentedSection();

            EditorWindowTools.DrawHorizontalLine();
            EditorGUILayout.LabelField("Player Response Menu", EditorStyles.boldLabel);
            EditorGUILayout.BeginHorizontal();
            DialogueManager.instance.displaySettings.inputSettings.alwaysForceResponseMenu = EditorGUILayout.Toggle("Always Force Menu", DialogueManager.instance.displaySettings.inputSettings.alwaysForceResponseMenu);
            EditorGUILayout.HelpBox("Tick to always force the response menu. If unticked, then when the player only has one valid response, the UI will automatically select it without showing the response menu.", MessageType.None);
            EditorGUILayout.EndHorizontal();
            EditorGUILayout.BeginHorizontal();
            DialogueManager.instance.displaySettings.inputSettings.includeInvalidEntries = EditorGUILayout.Toggle("Include Invalid Entries", DialogueManager.instance.displaySettings.inputSettings.includeInvalidEntries);
            EditorGUILayout.HelpBox("Tick to include entries whose conditions are false in the menu. Their buttons will be visible but non-interactable.", MessageType.None);
            EditorGUILayout.EndHorizontal();
            EditorGUILayout.BeginHorizontal();
            bool useTimeout = EditorGUILayout.Toggle("Timer", (DialogueManager.instance.displaySettings.inputSettings.responseTimeout > 0));

            EditorGUILayout.HelpBox("Tick to make the response menu timed. If unticked, players can take as long as they want to make their selection.", MessageType.None);
            EditorGUILayout.EndHorizontal();
            if (useTimeout)
            {
                if (Tools.ApproximatelyZero(DialogueManager.instance.displaySettings.inputSettings.responseTimeout))
                {
                    DialogueManager.instance.displaySettings.inputSettings.responseTimeout = DefaultResponseTimeoutDuration;
                }
                DialogueManager.instance.displaySettings.inputSettings.responseTimeout       = EditorGUILayout.FloatField("Timeout Seconds", DialogueManager.instance.displaySettings.inputSettings.responseTimeout);
                DialogueManager.instance.displaySettings.inputSettings.responseTimeoutAction = (ResponseTimeoutAction)EditorGUILayout.EnumPopup("If Time Runs Out", DialogueManager.instance.displaySettings.inputSettings.responseTimeoutAction);
            }
            else
            {
                DialogueManager.instance.displaySettings.inputSettings.responseTimeout = 0;
            }

            EditorWindowTools.DrawHorizontalLine();
            EditorGUILayout.LabelField("Quick Time Event (QTE) Trigger Buttons", EditorStyles.boldLabel);
            EditorGUILayout.HelpBox("QTE trigger buttons may be defined on the Dialogue Manager's inspector under Display Settings > Input Settings > QTE Input Buttons.", MessageType.None);
            if (GUILayout.Button("Inspect Dialogue Manager object", GUILayout.Width(240)))
            {
                Selection.activeObject = DialogueManager.instance;
            }

            EditorWindowTools.DrawHorizontalLine();
            EditorGUILayout.LabelField("Cancel Line", EditorStyles.boldLabel);
            EditorGUILayout.BeginHorizontal();
            DialogueManager.instance.displaySettings.inputSettings.cancel.key = (KeyCode)EditorGUILayout.EnumPopup("Key", DialogueManager.instance.displaySettings.inputSettings.cancel.key);
            EditorGUILayout.HelpBox("Pressing this key interrupts the currently-playing subtitle.", MessageType.None);
            EditorGUILayout.EndHorizontal();
            EditorGUILayout.BeginHorizontal();
            DialogueManager.instance.displaySettings.inputSettings.cancel.buttonName = EditorGUILayout.TextField("Button Name", DialogueManager.instance.displaySettings.inputSettings.cancel.buttonName);
            EditorGUILayout.HelpBox("Pressing this button interrupts the currently-playing subtitle.", MessageType.None);
            EditorGUILayout.EndHorizontal();

            EditorWindowTools.DrawHorizontalLine();
            EditorGUILayout.LabelField("Cancel Conversation", EditorStyles.boldLabel);
            EditorGUILayout.BeginHorizontal();
            DialogueManager.instance.displaySettings.inputSettings.cancelConversation.key = (KeyCode)EditorGUILayout.EnumPopup("Key", DialogueManager.instance.displaySettings.inputSettings.cancel.key);
            EditorGUILayout.HelpBox("Pressing this key cancels the conversation if in the response menu.", MessageType.None);
            EditorGUILayout.EndHorizontal();
            EditorGUILayout.BeginHorizontal();
            DialogueManager.instance.displaySettings.inputSettings.cancelConversation.buttonName = EditorGUILayout.TextField("Button Name", DialogueManager.instance.displaySettings.inputSettings.cancel.buttonName);
            EditorGUILayout.HelpBox("Pressing this button cancels the conversation if in the response menu.", MessageType.None);
            EditorGUILayout.EndHorizontal();

            EditorWindowTools.EndIndentedSection();
            EditorWindowTools.EndIndentedSection();
            DrawNavigationButtons(true, true, false);
        }
コード例 #3
0
        public override void ShowGUI(List <ActionParameter> parameters)
        {
            numSockets = EditorGUILayout.DelayedIntField("# of possible values:", numSockets);
            numSockets = Mathf.Clamp(numSockets, 1, 100);

            disallowSuccessive = EditorGUILayout.Toggle("Prevent same value twice?", disallowSuccessive);

            if (disallowSuccessive)
            {
                saveToVariable = EditorGUILayout.Toggle("Save last value?", saveToVariable);
                if (saveToVariable)
                {
                    location = (VariableLocation)EditorGUILayout.EnumPopup("Variable source:", location);

                    if (location == VariableLocation.Local && KickStarter.localVariables == null)
                    {
                        EditorGUILayout.HelpBox("No 'Local Variables' component found in the scene. Please add an AC GameEngine object from the Scene Manager.", MessageType.Info);
                    }
                    else if (location == VariableLocation.Local && isAssetFile)
                    {
                        EditorGUILayout.HelpBox("Local variables cannot be accessed in ActionList assets.", MessageType.Info);
                    }

                    if ((location == VariableLocation.Global && AdvGame.GetReferences().variablesManager != null) ||
                        (location == VariableLocation.Local && KickStarter.localVariables != null && !isAssetFile) ||
                        (location == VariableLocation.Component))
                    {
                        ParameterType _parameterType = ParameterType.GlobalVariable;
                        if (location == VariableLocation.Local)
                        {
                            _parameterType = ParameterType.LocalVariable;
                        }
                        else if (location == VariableLocation.Component)
                        {
                            _parameterType = ParameterType.ComponentVariable;
                        }

                        parameterID = Action.ChooseParameterGUI("Integer variable:", parameters, parameterID, _parameterType);
                        if (parameterID >= 0)
                        {
                            if (location == VariableLocation.Component)
                            {
                                variablesConstantID = 0;
                                variables           = null;
                            }

                            variableID = ShowVarGUI(variableID, false);
                        }
                        else
                        {
                            if (location == VariableLocation.Component)
                            {
                                variables           = (Variables)EditorGUILayout.ObjectField("Component:", variables, typeof(Variables), true);
                                variablesConstantID = FieldToID <Variables> (variables, variablesConstantID);
                                variables           = IDToField <Variables> (variables, variablesConstantID, false);

                                if (variables != null)
                                {
                                    variableID = ShowVarGUI(variableID, true);
                                }
                            }
                            else
                            {
                                EditorGUILayout.BeginHorizontal();
                                variableID = ShowVarGUI(variableID, true);

                                if (GUILayout.Button(string.Empty, CustomStyles.IconCog))
                                {
                                    SideMenu();
                                }
                                EditorGUILayout.EndHorizontal();
                            }
                        }
                    }
                }
            }
        }
コード例 #4
0
        private void DoCommands()
        {
            Event e = Event.current;

            switch (e.type)
            {
            case EventType.KeyDown:
            {
                if (Event.current.keyCode == KeyCode.Delete)
                {
                    if (TreeView.HasFocus())
                    {
                        RemoveAsset();
                    }
                }
                break;
            }
            }

            EditorGUILayout.BeginHorizontal();

            int  selectedRootItemsCount = TreeView.SelectedRootItemsCount;
            bool hasSelectedRootItems   = TreeView.HasSelectedRootItems;

            if (m_folders != null && m_folders.Length == 1)
            {
                if (GUILayout.Button("Add Asset"))
                {
                    PickObject();
                }
            }

            if (m_selectedRootItemsCount == 1)
            {
                if (GUILayout.Button("Rename Asset"))
                {
                    RenameAsset();
                }

                if (GUILayout.Button("Ping Asset"))
                {
                    PingAsset();
                }
            }
            m_selectedRootItemsCount = TreeView.SelectedRootItemsCount;

            if (m_hasSelectedRootItems)
            {
                if (GUILayout.Button("Remove Asset"))
                {
                    RemoveAsset();
                }
            }
            m_hasSelectedRootItems = TreeView.HasSelectedRootItems;

            EditorGUILayout.EndHorizontal();

            if (Event.current.commandName == "ObjectSelectorUpdated" && EditorGUIUtility.GetObjectPickerControlID() == m_currentPickerWindow)
            {
                m_pickedObject = EditorGUIUtility.GetObjectPickerObject();
            }
            else
            {
                if (Event.current.commandName == "ObjectSelectorClosed" && EditorGUIUtility.GetObjectPickerControlID() == m_currentPickerWindow)
                {
                    m_currentPickerWindow = -1;
                    if (m_pickedObject != null)
                    {
                        if (m_folders[0].Assets == null || !m_folders[0].Assets.Any(a => a.Object == m_pickedObject || a.Object != null && a.Object.name == m_pickedObject.name && a.Object.GetType() == m_pickedObject.GetType()))
                        {
                            if (m_pickedObject == null || m_pickedObject.GetType().Assembly.FullName.Contains("UnityEditor") && m_pickedObject.GetType() != typeof(AnimatorController))
                            {
                                EditorUtility.DisplayDialog("Unable to add asset",
                                                            string.Format("Unable to add asset {0} from assembly {1}", m_pickedObject.GetType().Name, m_pickedObject.GetType().Assembly.GetName()), "OK");
                            }
                            else
                            {
                                bool moveToNewLocation = MoveToNewLocationDialog(new[] { m_pickedObject }, m_folders[0]);


                                AddAssetToFolder(new[] { m_pickedObject }, m_folders[0], moveToNewLocation);
                            }
                        }
                        m_pickedObject = null;
                    }
                }
            }
        }
コード例 #5
0
    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();

        SwiftShadow.LightVectorSourceEnum lightVectorSource = (SwiftShadow.LightVectorSourceEnum)DoFieldProperty <int>(
            _lightVectorSource,
            new GUIContent(
                "Light direction from: ",
                ""
                ),
            "LightVectorSource",
            (rect, label, property) =>
            EditorGUI.Popup(rect, label, property.enumValueIndex, EditorGUIUtilityInternal.TempContent(new string[] { "Static vector", "Light source object" })));

        EditorGUI.indentLevel++;
        if (lightVectorSource == SwiftShadow.LightVectorSourceEnum.StaticVector)
        {
            DoFieldProperty(
                _lightVector,
                new GUIContent(
                    "Direction vector: ",
                    "Light direction vector relative to the object. For example, (0, -1, 0) means the light always come from right above."
                    ),
                "LightVector",
                (rect, label, property) => EditorGUI.Vector3Field(rect, label.text, property.vector3Value));
        }
        else
        {
            Transform lightSourceObject = DoFieldProperty <Transform>(
                _lightSourceObject,
                new GUIContent(
                    "Light source: ",
                    "The GameObject that'll be used as point light source for this shadow."
                    ),
                "LightSourceObject",
                (rect, label, property) => (Transform)EditorGUI.ObjectField(rect, label, property.objectReferenceValue, typeof(Transform), true));

            if (lightSourceObject == null)
            {
                EditorGUILayout.HelpBox("No light source selected. Shadow will use the static vector instead.", MessageType.Warning, false);
            }
        }
        EditorGUI.indentLevel--;

        DoFieldProperty <LayerMask>(
            _layerMask,
            new GUIContent(
                "Raycast layer mask: ",
                "Layers to cast shadows on. " +
                "You must to exclude the layer of the object " +
                "itself if it has a collider attached to it, otherwise shadow may behave strange."
                ),
            "LayerMask",
            (rect, label, property) => {
            EditorGUIInternal.LayerMaskField(rect, property, label);
            return(0);
        });

        if (_layerMask.intValue == 0)
        {
            EditorGUILayout.HelpBox("No layer mask is set. Shadows won't project on anything.", MessageType.Warning, false);
        }

        EditorGUILayout.HelpBox("Shadow", MessageType.None, true);

        Material shadowMaterial = DoFieldProperty(
            _material,
            new GUIContent(
                "Material: ",
                "Material that'll be used for rendering the shadow."
                ),
            "Material",
            (rect, label, property) => (Material)EditorGUI.ObjectField(rect, label, property.objectReferenceValue, typeof(Material), false));

        if (shadowMaterial == null)
        {
            EditorGUILayout.HelpBox("No material assigned. Shadow will use the default blob shadow.", MessageType.Info, false);
        }

        DoFieldProperty(
            _color,
            new GUIContent(
                "Shadow color: ",
                "The color of the shadow."
                ),
            "Color",
            (rect, label, property) => EditorGUI.ColorField(rect, label, property.colorValue));

        DoFieldProperty(
            _shadowSize,
            new GUIContent(
                "Shadow size: ",
                "Scale of shadow relative to object's max dimensions."
                ),
            "ShadowSize",
            (rect, label, property) => EditorGUI.FloatField(rect, label, property.floatValue));

        EditorGUILayout.BeginHorizontal();
#if !UNITY_3_5
        GUILayout.Space(EditorGUIUtilityInternal.labelWidth);
#else
        GUILayout.Space(EditorGUIUtilityInternal.labelWidth + 4f);
#endif

        if (GUILayout.Button("Estimate size"))
        {
            GUI.changed = true;

            foreach (Object targetObject in _shadowSize.serializedObject.targetObjects)
            {
                SwiftShadow shadow     = (SwiftShadow)targetObject;
                GameObject  go         = shadow.gameObject;
                Quaternion  goRotation = go.transform.rotation;
                go.transform.rotation = Quaternion.identity;

                Bounds bounds = new Bounds(go.transform.position, Vector3.zero);
                foreach (Renderer renderer in go.GetComponentsInChildren <Renderer>())
                {
                    bounds.Encapsulate(renderer.bounds);
                }

                if (bounds.size.magnitude > Vector3.kEpsilon)
                {
                    float scaleMin = Mathf.Min(go.transform.lossyScale.x, go.transform.lossyScale.y, go.transform.lossyScale.z);
                    shadow.ShadowSize = Mathf.Max(bounds.size.x, bounds.size.y, bounds.size.z) / scaleMin;
                    shadow.ShadowSize = (float)Math.Round(shadow.ShadowSize, 5);
                }
                go.transform.rotation = goRotation;
            }
            _shadowSize.serializedObject.ApplyModifiedProperties();
            _shadowSize.serializedObject.SetIsDifferentCacheDirty();

            Repaint();
        }

        EditorGUILayout.EndHorizontal();

        GUI.enabled = lightVectorSource == SwiftShadow.LightVectorSourceEnum.GameObject;
        DoFieldProperty(
            _isPerspectiveProjection,
            new GUIContent(
                "Perspective projection: ",
                "Makes shadows bigger as they move away from the light source. " +
                "This usually looks more realistic, but may result in artifacts at extreme angles."
                ),
            "IsPerspectiveProjection",
            (rect, label, property) => EditorGUI.Toggle(rect, label, property.boolValue));
        GUI.enabled = true;

        DoFieldProperty(
            _projectionDistance,
            new GUIContent(
                "Projection distance: ",
                "Maximal distance from the transform position to the surface shadow will fall on."
                ),
            "ProjectionDistance",
            (rect, label, property) => EditorGUI.FloatField(rect, label, property.floatValue));

        EditorGUI.indentLevel++;
        EditorGUILayout.BeginHorizontal(GUILayout.Width(100f));
        EditorGUILayout.HelpBox("Fading", MessageType.None, true);
        EditorGUILayout.EndHorizontal();

        DoFieldProperty(
            _fadeDistance,
            new GUIContent(
                "Fade distance: ",
                "Distance at which shadow will start fading out. Used for smooth transition to \"Projection distance\""
                ),
            "FadeDistance",
            (rect, label, property) => EditorGUI.FloatField(rect, label, property.floatValue));

        DoFieldProperty(
            _angleFadeMin,
            new GUIContent(
                "Angle fade from: ",
                "The angle at which the shadow will start fading out. Used for smooth transition to \"Max angle\""
                ),
            "AngleFadeMin",
            (rect, label, property) => EditorGUI.FloatField(rect, label, property.floatValue));

        DoFieldProperty(
            _angleFadeMax,
            new GUIContent(
                "Max angle: ",
                "The maximum angle at which the shadow is allowed to fall on surface. " +
                "It it falls at a bigger angle, no shadow will be rendered."
                ),
            "AngleFadeMax",
            (rect, label, property) => EditorGUI.FloatField(rect, label, property.floatValue));

        EditorGUILayout.BeginHorizontal(GUILayout.Width(100f));
        EditorGUILayout.HelpBox("Static", MessageType.None, true);
        EditorGUILayout.EndHorizontal();

        DoFieldProperty(
            _isStatic,
            new GUIContent(
                "Static: ",
                "If checked, the shadow will be calculated only at the creation. " +
                "Use this for shadows that do not move for a huge perfomance boost."),
            "IsStatic",
            (rect, label, property) => {
            EditorGUILayout.BeginHorizontal();

            Rect labelRect  = rect;
            labelRect.width = GUI.skin.label.CalcSize(label).x + EditorGUILayoutExtensions.kIndentationWidth;
            labelRect.xMin += EditorGUILayoutExtensions.kIndentationWidth;
            rect.xMin       = labelRect.xMax;

            GUI.Label(labelRect, label);
            bool result = EditorGUI.Toggle(rect, property.boolValue);
            EditorGUILayout.EndHorizontal();

            return(result);
        });

        DoFieldProperty(
            _autoStaticTime,
            new GUIContent(
                "Set to static if not moving for",
                "Makes shadow static if it hasn't moved for X seconds. " +
                "Shadow will return to non-static state when moving or rotating. " +
                "This is useful for optimizing performance if you have shadow that " +
                "only move from time to time. Value of 0 disables this setting."
                ),
            "AutoStaticTime",
            (rect, label, property) => {
            GUIContent secText = new GUIContent("sec.");

            Rect labelRect  = rect;
            labelRect.width = GUI.skin.label.CalcSize(label).x + EditorGUILayoutExtensions.kIndentationWidth;
            labelRect.xMin += EditorGUILayoutExtensions.kIndentationWidth;
            rect.xMin       = labelRect.xMax;

            GUI.Label(labelRect, label);

            labelRect      = rect;
            labelRect.xMin = rect.xMax - GUI.skin.label.CalcSize(secText).x;

            rect.xMax = labelRect.xMin;

            float result = EditorGUI.FloatField(rect, property.floatValue);

            GUI.Label(labelRect, secText);

            return(result);
        }
            );

        EditorGUI.indentLevel--;
        EditorGUILayout.HelpBox("Advanced", MessageType.None, true);

        DoFieldProperty(
            _textureUVRect,
            new GUIContent(
                "Texture coordinates: ",
                "The texture coordinates of shadow. Change this to use multiple shadow cookies within the material texture."
                ),
            "TextureUVRect",
            (rect, label, property) => EditorGUI.RectField(rect, label, property.rectValue));

        DoFieldProperty(
            _aspectRatio,
            new GUIContent("Aspect ratio: ", "The width/height aspect ratio of shadow."),
            "AspectRatio",
            (rect, label, property) => EditorGUI.FloatField(rect, label, property.floatValue));

        DoFieldProperty(
            _shadowOffset,
            new GUIContent(
                "Shadow offset: ",
                "The distance at which the shadow hovers above the surface. " +
                "Increase this value if you see shadows flickering due to Z-fighting"
                ),
            "ShadowOffset",
            (rect, label, property) => EditorGUI.FloatField(rect, label, property.floatValue));

        DoFieldProperty(
            _frameSkip,
            new GUIContent(
                "Frame skip: ",
                "Skip N frames before updating the shadow. " +
                "Can be useful if you don't need to update shadow too often."
                ),
            "FrameSkip",
            (rect, label, property) => EditorGUI.IntSlider(rect, label, property.intValue, 0, 50));

        DoFieldProperty(
            _cullInvisible,
            new GUIContent(
                "Ignore culling: ",
                "If selected, the camera culling will be disabled. " +
                "Check this for a small performance gain if shadow is always in sight."
                ),
            "CullInvisible",
            (rect, label, property) => !EditorGUI.Toggle(rect, label, !property.boolValue));

        bool useForceLayer = DoFieldProperty(
            _useForceLayer,
            new GUIContent(
                "Shadow layer: ",
                "The layer at which the shadow will be rendered."
                ),
            "UseForceLayer",
            (rect, label, property) =>
            EditorGUI.Popup(rect, label, property.boolValue ? 1 : 0, EditorGUIUtilityInternal.TempContent(new string[] { "Same as GameObject", "Manual" })) == 1);

        if (useForceLayer)
        {
            EditorGUI.indentLevel++;
            DoFieldProperty(
                _forceLayer,
                new GUIContent(
                    "Layer: ",
                    ""
                    ),
                "ForceLayer",
                (rect, label, property) => EditorGUI.LayerField(rect, label, _forceLayer.intValue));
            EditorGUI.indentLevel--;
        }

        serializedObject.ApplyModifiedProperties();
    }
コード例 #6
0
ファイル: TMP_SubMesh_Editor.cs プロジェクト: soulnai/SilkWay
        public override void OnInspectorGUI()
        {
            EditorGUI.indentLevel = 0;

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("Sorting Layer");
            EditorGUI.BeginChangeCheck();

            //float old_LabelWidth = EditorGUIUtility.labelWidth;
            //float old_fieldWidth = EditorGUIUtility.fieldWidth;


            // SORTING LAYERS
            var sortingLayerNames = SortingLayerHelper.sortingLayerNames;

            // Look up the layer name using the current layer ID
            string oldName = SortingLayerHelper.GetSortingLayerNameFromID(m_Renderer.sortingLayerID);

            // Use the name to look up our array index into the names list
            int oldLayerIndex = System.Array.IndexOf(sortingLayerNames, oldName);

            // Show the pop-up for the names
            EditorGUIUtility.fieldWidth = 0f;
            int newLayerIndex = EditorGUILayout.Popup(string.Empty, oldLayerIndex, sortingLayerNames, GUILayout.MinWidth(80f));

            // If the index changes, look up the ID for the new index to store as the new ID
            if (newLayerIndex != oldLayerIndex)
            {
                //Undo.RecordObject(renderer, "Edit Sorting Layer");
                m_Renderer.sortingLayerID = SortingLayerHelper.GetSortingLayerIDForIndex(newLayerIndex);
                //EditorUtility.SetDirty(renderer);
            }

            // Expose the manual sorting order
            EditorGUIUtility.labelWidth = 40f;
            EditorGUIUtility.fieldWidth = 80f;
            int newSortingLayerOrder = EditorGUILayout.IntField("Order", m_Renderer.sortingOrder);

            if (newSortingLayerOrder != m_Renderer.sortingOrder)
            {
                //Undo.RecordObject(renderer, "Edit Sorting Order");
                m_Renderer.sortingOrder = newSortingLayerOrder;
            }
            EditorGUILayout.EndHorizontal();

            //    // If a Custom Material Editor exists, we use it.
            //    if (m_canvasRenderer != null && m_canvasRenderer.GetMaterial() != null)
            //    {
            //        Material mat = m_canvasRenderer.GetMaterial();

            //        //Debug.Log(mat + "  " + m_targetMaterial);

            //        if (mat != m_targetMaterial)
            //        {
            //            // Destroy previous Material Instance
            //            //Debug.Log("New Material has been assigned.");
            //            m_targetMaterial = mat;
            //            DestroyImmediate(m_materialEditor);
            //        }


            //        if (m_materialEditor == null)
            //        {
            //            m_materialEditor = Editor.CreateEditor(mat);
            //        }

            //        m_materialEditor.DrawHeader();


            //        m_materialEditor.OnInspectorGUI();
            //    }
        }
コード例 #7
0
        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
        {
            EditorGUI.BeginProperty(position, label, property);

            // Limit valid characters.
            // TODO: This might not be necessary since name will need to be sanitized for different needs later (as an enum entry, pre-processor define, etc.)
            //char chr = Event.current.character;
            //if ((chr < 'a' || chr > 'z') && (chr < 'A' || chr > 'Z') && (chr < '0' || chr > '9') && chr != '-' && chr != '_' && chr != ' ')
            //{
            //    Event.current.character = '\0';
            //}

            bool show = property.isExpanded;

            UnityBuildGUIUtility.DropdownHeader(property.FindPropertyRelative("typeName").stringValue, ref show, false);
            property.isExpanded = show;

            if (show)
            {
                EditorGUILayout.BeginVertical(UnityBuildGUIUtility.dropdownContentStyle);

                GUILayout.Label("Basic Info", UnityBuildGUIUtility.midHeaderStyle);

                SerializedProperty typeName = property.FindPropertyRelative("typeName");

                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.PrefixLabel("Type Name");
                typeName.stringValue = BuildProject.SanitizeFolderName(GUILayout.TextArea(typeName.stringValue));
                EditorGUILayout.EndHorizontal();

                EditorGUILayout.PropertyField(property.FindPropertyRelative("bundleIdentifier"));
                EditorGUILayout.PropertyField(property.FindPropertyRelative("productName"));
                EditorGUILayout.PropertyField(property.FindPropertyRelative("companyName"));

                GUILayout.Space(20);
                GUILayout.Label("Build Options", UnityBuildGUIUtility.midHeaderStyle);

                EditorGUILayout.PropertyField(property.FindPropertyRelative("customDefines"));

                SerializedProperty buildOptions = property.FindPropertyRelative("buildOptions");

                bool enableHeadlessMode = ((BuildOptions)buildOptions.intValue & BuildOptions.EnableHeadlessMode) == BuildOptions.EnableHeadlessMode;
                bool developmentBuild   = ((BuildOptions)buildOptions.intValue & BuildOptions.Development) == BuildOptions.Development;
                bool allowDebugging     = ((BuildOptions)buildOptions.intValue & BuildOptions.AllowDebugging) == BuildOptions.AllowDebugging;

                enableHeadlessMode = EditorGUILayout.ToggleLeft(" Server Build", enableHeadlessMode);
                if (enableHeadlessMode)
                {
                    buildOptions.intValue |= (int)BuildOptions.EnableHeadlessMode;
                }
                else
                {
                    buildOptions.intValue &= ~(int)BuildOptions.EnableHeadlessMode;
                }

                developmentBuild = EditorGUILayout.ToggleLeft(" Development Build", developmentBuild);
                if (developmentBuild)
                {
                    buildOptions.intValue |= (int)BuildOptions.Development;
                }
                else
                {
                    buildOptions.intValue &= ~(int)BuildOptions.Development;
                }

                EditorGUI.BeginDisabledGroup(!developmentBuild);
                allowDebugging = EditorGUILayout.ToggleLeft(" Script Debugging", allowDebugging);
                EditorGUI.EndDisabledGroup();
                if (allowDebugging)
                {
                    buildOptions.intValue |= (int)BuildOptions.AllowDebugging;
                }
                else
                {
                    buildOptions.intValue &= ~(int)BuildOptions.AllowDebugging;
                }

                buildOptions.intValue = (int)(BuildOptions)EditorGUILayout.EnumFlagsField("Advanced", (BuildOptions)buildOptions.intValue);

                EditorGUILayout.PropertyField(property.FindPropertyRelative("sceneList"));

                GUILayout.BeginHorizontal();
                GUILayout.FlexibleSpace();
                if (GUILayout.Button("Delete", GUILayout.MaxWidth(150)))
                {
                    BuildReleaseType[] types = BuildSettings.releaseTypeList.releaseTypes;
                    for (int i = 0; i < types.Length; i++)
                    {
                        if (types[i].typeName == property.FindPropertyRelative("typeName").stringValue)
                        {
                            ArrayUtility.RemoveAt <BuildReleaseType>(ref BuildSettings.releaseTypeList.releaseTypes, i);
                            GUIUtility.keyboardControl = 0;
                            break;
                        }
                    }
                }
                GUILayout.FlexibleSpace();
                GUILayout.EndHorizontal();

                property.serializedObject.ApplyModifiedProperties();

                EditorGUILayout.EndVertical();
            }

            EditorGUI.EndProperty();
        }
コード例 #8
0
 public override void Draw()
 {
     EditorGUILayout.BeginHorizontal();
     base.Draw();
     EditorGUILayout.EndHorizontal();
 }
コード例 #9
0
    void OnGUI()
    {
        GUILayout.BeginHorizontal();
        {
            GUILayout.FlexibleSpace();
            GUILayout.BeginVertical();
            {
                GUILayout.FlexibleSpace();

                if (updateNeeded)
                {
                    EditorGUILayout.LabelField("A new version is available : " + version, EditorStyles.wordWrappedLabel);
                    GUILayout.Space(20);
                    if (_automaticUpdate)
                    {
                        EditorGUILayout.BeginHorizontal();
                        {
                            GUILayout.FlexibleSpace();
                            EditorPrefs.SetBool("PiXYZ.AutoUpdate", !EditorGUILayout.Toggle("Do not show Again", !EditorPrefs.GetBool("PiXYZ.AutoUpdate")));
                            GUILayout.FlexibleSpace();
                        }
                        EditorGUILayout.EndHorizontal();
                    }


                    GUILayout.BeginHorizontal();
                    if (GUILayout.Button("Download"))
                    {
                        Application.OpenURL(link);
                        this.Close();
                    }
                    if (GUILayout.Button("Later"))
                    {
                        this.Close();
                    }
                    GUILayout.EndHorizontal();
                }
                else if (errorMessage == "")
                {
                    EditorGUILayout.LabelField("Your version is up to date", EditorStyles.wordWrappedLabel);
                    GUILayout.Space(20);
                    GUILayout.BeginHorizontal();
                    if (GUILayout.Button("Close"))
                    {
                        this.Close();
                    }
                    GUILayout.EndHorizontal();
                }
                else
                {
                    EditorGUILayout.LabelField(errorMessage, EditorStyles.wordWrappedLabel);
                    GUILayout.Space(20);
                    GUILayout.BeginHorizontal();
                    if (GUILayout.Button("Retry"))
                    {
                        errorMessage = "";
                        checkForUpdate();
                    }

                    if (GUILayout.Button("Close"))
                    {
                        this.Close();
                        errorMessage = "";
                    }
                    GUILayout.EndHorizontal();
                }
                GUILayout.FlexibleSpace();
            }
            GUILayout.EndVertical();
            GUILayout.FlexibleSpace();
        }
        GUILayout.EndHorizontal();
    }
コード例 #10
0
    public override void OnInspectorGUI()
    {
        GUI.skin = Skin;
        CustomIKSolver t = target as CustomIKSolver;

        serializedObject.Update();

        EditorGUILayout.PrefixLabel(new GUIContent(IKTexture));
        //GUI.color = new Color(61.0f / 255.0f, 147.0f / 255.0f, 160.0f / 255.0f);

        EditorGUILayout.BeginHorizontal("box");
        t.label = EditorGUILayout.TextField(t.label); // draw name box
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.BeginVertical("box"); // 0
        EditorGUILayout.BeginHorizontal("box");
        GUILayout.Label(new GUIContent(IKTexture), GUILayout.Width(16));
        if (GUILayout.Button("Joints"))     // draw joints
        {
            IKActive = !IKActive;
        }

        EditorGUILayout.EndHorizontal();

        if (IKActive)
        {
            EditorGUI.indentLevel++;

            // Enter the array

            if (t.Joints.Count > 0)
            {
                JointsProp = serializedObject.FindProperty("Joints");
                JointsProp.Next(true);
                JointsProp.Next(true);
                JointsProp.Next(true);
            }
            //

            // loop through array
            for (int i = 0; i < t.Joints.Count; i++)
            {
                GUI.color = new Color(1, 1, 1);

                EditorGUILayout.BeginVertical("box"); // 1
                EditorGUILayout.BeginHorizontal();    // 1

                if (t.Joints[i] != null)
                {
                    EditorGUILayout.LabelField(new GUIContent(t.Joints[i].name), GUILayout.Width(100));
                }
                else
                {
                    EditorGUILayout.LabelField(new GUIContent("!Empty!"), GUILayout.Width(100));
                }

                EditorGUILayout.PropertyField(JointsProp);
                if (GUILayout.Button("X")) // remove
                {
                    t.Joints.RemoveAt(i);
                }


                EditorGUILayout.EndHorizontal(); // 1

                if (t.Joints[i] != null)
                {
                    EditorGUILayout.BeginHorizontal(); // 2
                    if (!t.Joints[i].detailToggle)
                    {
                        GUILayout.Label(new GUIContent(PlusTexture), GUILayout.Width(16));
                    }
                    else
                    {
                        GUILayout.Label(new GUIContent(MinusTexture), GUILayout.Width(16));
                    }

                    if (GUILayout.Button("Details", GUILayout.Width(100 - 16))) //
                    {
                        t.Joints[i].detailToggle = !t.Joints[i].detailToggle;
                    }
                    EditorGUILayout.EndHorizontal(); // 2

                    if (t.Joints[i].detailToggle)
                    {
                        GUILayout.Label(new GUIContent("Start Offset: " + t.Joints[i].transform.localPosition));
                        GUILayout.Label(new GUIContent("Position: " + t.Joints[i].transform.position));
                    }
                }

                EditorGUILayout.EndVertical();// 1

                GUI.color = Color.white;
                JointsProp.Next(false);
            }


            // add
            EditorGUILayout.BeginHorizontal("box");

            GUILayout.Label(new GUIContent(PlusTexture), GUILayout.Width(16));
            if (GUILayout.Button("ADD"))
            {
                t.Joints.Add(null);
            }
            GUILayout.Label(new GUIContent(PlusTexture), GUILayout.Width(16));

            EditorGUILayout.EndHorizontal();



            EditorGUI.indentLevel--;
        }

        EditorGUILayout.EndVertical(); // 0


        EditorGUILayout.BeginVertical("box");

        EditorGUILayout.PropertyField(AnkleProp);
        EditorGUILayout.PropertyField(TargetProp);
        EditorGUILayout.PropertyField(ItterationsProp);
        serializedObject.ApplyModifiedProperties();

        GUILayout.Space(20);

        t.Visualise = EditorGUILayout.Toggle("Visualise:", t.Visualise);

        EditorGUILayout.EndVertical();

        GUILayout.Space(20);
        //base.OnInspectorGUI();
    }
コード例 #11
0
        private int RenderScreensList <T>(string title, List <T> screens, Action <int> RemoveHandler, Action AddHandler, int firstIndex, string addButtonLabel, bool pickFirst, string firstLabel = null) where T : UIScreen
        {
            string[] options = new string[screens.Count];

            if (screens.Count > 0)
            {
                EditorGUILayout.LabelField(title + ":");
            }

            int removeScreen = -1;

            for (int i = 0; i < screens.Count; i++)
            {
                T screen = screens[i];

                EditorGUILayout.BeginHorizontal();

                T newScreen = EditorGUILayout.ObjectField(screen, typeof(T), true) as T;
                if (!IsDuplicate <T>(newScreen, screens))
                {
                    screens[i] = newScreen;
                }

                if (screen != null)
                {
                    options[i] = screen.name;
                }
                else
                {
                    options[i] = none;
                }

                if (screens[i] != null && screens[i].CustomID != null)
                {
                    EditorGUILayout.LabelField("ID: \"" + screens[i].CustomID + "\"", GUILayout.MaxWidth(120f));
                    //EditorGUILayout.SelectableLabel("Custom ID: " + screens[i].CustomID);
                }

                if (GUILayout.Button("-", GUILayout.Width(20)))
                {
                    if (EditorUtility.DisplayDialog("Confirm", "Are you sure?", "Yes", "No"))
                    {
                        removeScreen = i;
                    }
                }

                EditorGUILayout.EndHorizontal();
            }

            if (removeScreen >= 0 && RemoveHandler != null)
            {
                RemoveHandler(removeScreen);
            }

            if (GUILayout.Button(addButtonLabel) && AddHandler != null)
            {
                AddHandler();
            }

            if (pickFirst && screens.Count > 0)
            {
                GUILayout.Space(4);

                int index = EditorGUILayout.Popup(firstLabel, firstIndex, options);
                if (options.Length > 0 && !options[index].Equals(none))
                {
                    firstIndex = index;
                }
            }
            else
            {
                firstIndex = 0;
            }

            return(firstIndex);
        }
コード例 #12
0
    public void DrawEvents(Dictionary <int, EventHandler.GameEvent> dic, string removeString)
    {
        // Sort for desired events
        var Events =
            (
                from e in dic.Values
                where SelectEvent(e)
                orderby e.GetEventType() ascending
                select e
            ).ToArray();

        eventInfoOption = GUILayout.Toolbar(eventInfoOption, eventDisplay);
        EditorGUILayout.LabelField(string.Format("Event Count : {0}", Events.Length), EditorStyles.boldLabel);
        EditorGUILayout.LabelField(string.Format("Current Frame : {0}", Time.frameCount));

        EditorGUILayout.BeginHorizontal();
        searchValue = EditorGUILayout.TextField("Search", searchValue, GUILayout.Width(Screen.width - Screen.width / 5f));
        searchType  = (SearchType)EditorGUILayout.EnumPopup(searchType);
        EditorGUILayout.EndHorizontal();

        // Draw naviation buttons if there is too many to show
        if (Events.Length > eventItems)
        {
            EditorGUILayout.LabelField(string.Format("Page {0}", window, GUILayout.Width(Screen.width / 6f)));
            EditorGUILayout.BeginHorizontal();
            if (window * eventItems < eventItems)
            {
                GUI.enabled = false;
            }
            if (GUILayout.Button(string.Format("Previous {0}", eventItems)))
            {
                window--;
            }
            GUI.enabled = true;

            if (window * eventItems >= Events.Length)
            {
                Debug.Log("Shrink");
                window = (Events.Length - Events.Length % eventItems) / eventItems;
                if (window * eventItems == Events.Length)
                {
                    window -= 1;
                }
            }

            if (window * eventItems + eventItems >= Events.Length)
            {
                GUI.enabled = false;
            }
            if (GUILayout.Button(string.Format("Next {0}", eventItems)))
            {
                window++;
            }
            GUI.enabled = true;
            EditorGUILayout.EndHorizontal();
        }
        else
        {
            window = 0;
        }

        // Draw Event Info
        for (int itr = window * eventItems; itr < window * eventItems + eventItems; ++itr)
        {
            if (itr > Events.Length - 1)
            {
                continue;
            }
            var item = Events[itr];

            if (item.Subscriber.Count == 0)
            {
                continue;
            }

            var foldout = item.GetEventType().ToString().Replace(removeString, "");

            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
            {
                EditorGUI.indentLevel++;
                item.show = EditorGUILayout.Foldout(item.show, new GUIContent(string.Format("{0} : {1}", foldout, item.Subscriber.Count), "Event Name"), true);
                if (item.show)
                {
                    if (eventInfoOption == 0)
                    {
                        foreach (var subscriber in item.Subscriber)
                        {
                            if (searchType == SearchType.Subscriber)
                            {
                                if (subscriber == null || !(subscriber.GetType().ToString().IndexOf(searchValue, StringComparison.OrdinalIgnoreCase) >= 0))
                                {
                                    continue;
                                }
                            }

                            if (subscriber == null)
                            {
                                EditorGUILayout.LabelField("NULL SUBSCRIBER");
                            }
                            else if (subscriber is MonoBehaviour)
                            {
                                var system = subscriber as MonoBehaviour;
                                if (GUI.Button(EditorGUI.IndentedRect(EditorGUILayout.GetControlRect()), string.Format("{1} ({0})", system.gameObject.name, system.GetType().ToString()), EditorStyles.label))
                                {
                                    EditorGUIUtility.PingObject(system);
                                }
                            }
                            else
                            {
                                EditorGUILayout.LabelField(subscriber.GetType().ToString());
                            }
                        }
                    }
                    else
                    {
                        var invokers = item.EventInvokers.ToArray();
                        if (invokers.Length > 0)
                        {
                            for (int i = invokers.Length - 1; i >= 0; --i)
                            {
                                var invoker = invokers[i];
                                EditorGUILayout.BeginHorizontal();

                                EditorGUILayout.LabelField(string.Format("Frame:{0}", invoker.frame), GUILayout.Width(Screen.width / 4f));

                                if (invoker.invoker is MonoBehaviour)
                                {
                                    var invokeSystem = invoker.invoker as MonoBehaviour;
                                    if (invokeSystem == null)
                                    {
                                        EditorGUILayout.LabelField("Deleted");
                                    }
                                    else
                                    {
                                        if (GUILayout.Button(string.Format("{0}:{1}", invokeSystem.gameObject.name, invokeSystem.GetType().ToString()), EditorStyles.label))
                                        {
                                            EditorGUIUtility.PingObject(invokeSystem);
                                        }
                                    }
                                }
                                else
                                {
                                    if (invoker.invoker == null)
                                    {
                                        EditorGUILayout.LabelField("NULL INVOKER");
                                    }
                                    else
                                    {
                                        EditorGUILayout.LabelField(invoker.invoker.GetType().ToString());
                                    }
                                }

                                EditorGUILayout.EndHorizontal();
                            }
                        }
                        else
                        {
                            EditorGUILayout.LabelField("No Invokers");
                        }
                    }
                }
                EditorGUI.indentLevel--;
            }
            EditorGUILayout.EndVertical();
        }
    }
コード例 #13
0
        private void DrawClass(RPGDatabaseManager database)
        {
            var weaponTypeIds   = database.FetchEntry <WeaponTypeDataList>().entries.Select(l => l.Id).ToArray();
            var weaponTypeNames = database.FetchEntry <WeaponTypeDataList>().entries.Select(l => l.name).ToArray();
            var skillIds        = database.FetchEntry <SkillDataList>().entries.Select(l => l.Id).ToArray();
            var skillNames      = database.FetchEntry <SkillDataList>().entries.Select(l => l.name).ToArray();

            var entry = (ActorClassData)entrySelected;

            EditorGUILayout.BeginVertical("GroupBox", GUILayout.Width(400));
            classAreaVect = EditorGUILayout.BeginScrollView(classAreaVect, GUILayout.Width(400));

            DrawTitle();
            entry.name = EditorGUILayout.TextField("Name", entry.name);


            #region Growth
            BrightEditorGUILayout.LabelFieldBold("Growth");
            entry.expCurve = EditorGUILayout.CurveField(Constants.Attributes.EXP, entry.expCurve, GUILayout.Height(25f));
            entry.hpCurve  = EditorGUILayout.CurveField(Constants.Attributes.HP, entry.hpCurve, GUILayout.Height(25f));
            entry.mpCurve  = EditorGUILayout.CurveField(Constants.Attributes.MP, entry.mpCurve, GUILayout.Height(25f));

            entry.strCurve = EditorGUILayout.CurveField(Constants.Attributes.STR, entry.strCurve, GUILayout.Height(25f));
            entry.intCurve = EditorGUILayout.CurveField(Constants.Attributes.INT, entry.intCurve, GUILayout.Height(25f));

            entry.dexCurve = EditorGUILayout.CurveField(Constants.Attributes.DEX, entry.dexCurve, GUILayout.Height(25f));
            entry.agiCurve = EditorGUILayout.CurveField(Constants.Attributes.AGI, entry.agiCurve, GUILayout.Height(25f));
            entry.lckCurve = EditorGUILayout.CurveField(Constants.Attributes.LCK, entry.lckCurve, GUILayout.Height(25f));

            entry.defCurve = EditorGUILayout.CurveField(Constants.Attributes.DEF, entry.defCurve, GUILayout.Height(25f));
            entry.resCurve = EditorGUILayout.CurveField(Constants.Attributes.RES, entry.resCurve, GUILayout.Height(25f));
            #endregion

            #region Preview
            EditorGUILayout.BeginVertical("GroupBox", GUILayout.Width(350));
            var list  = database.FetchEntry <AttributeSpecDataList>();
            var level = list.entries.First(x => x.name == Constants.Attributes.LEVEL);
            var exp   = list.entries.First(x => x.name == Constants.Attributes.EXP);

            var hp   = list.entries.First(x => x.name == Constants.Attributes.HP);
            var mp   = list.entries.First(x => x.name == Constants.Attributes.MP);
            var attr = list.entries.First(x => x.name == Constants.Attributes.COMMON);

            BrightEditorGUILayout.LabelFieldBold("Preview");
            previewLv = EditorGUILayout.IntSlider(Constants.Attributes.LEVEL_SHORT, previewLv, level.start, level.end);

            float normalizedValue  = Mathf.InverseLerp(level.start, level.end, previewLv);
            float targetCurveValue = 0f;

            targetCurveValue = entry.expCurve.Evaluate(normalizedValue);
            EditorGUILayout.LabelField($"{Constants.Attributes.EXP}:\t{exp.FetchAtCurvePoint(targetCurveValue)}");

            targetCurveValue = entry.hpCurve.Evaluate(normalizedValue);
            EditorGUILayout.LabelField($"{Constants.Attributes.HP}:\t{hp.FetchAtCurvePoint(targetCurveValue)}");
            targetCurveValue = entry.mpCurve.Evaluate(normalizedValue);
            EditorGUILayout.LabelField($"{Constants.Attributes.MP}:\t{mp.FetchAtCurvePoint(targetCurveValue)}");

            targetCurveValue = entry.strCurve.Evaluate(normalizedValue);
            EditorGUILayout.LabelField($"{Constants.Attributes.STR_SHORT}:\t{attr.FetchAtCurvePoint(targetCurveValue)}");
            targetCurveValue = entry.intCurve.Evaluate(normalizedValue);
            EditorGUILayout.LabelField($"{Constants.Attributes.INT_SHORT}:\t{attr.FetchAtCurvePoint(targetCurveValue)}");

            targetCurveValue = entry.dexCurve.Evaluate(normalizedValue);
            EditorGUILayout.LabelField($"{Constants.Attributes.DEX_SHORT}:\t{attr.FetchAtCurvePoint(targetCurveValue)}");
            targetCurveValue = entry.agiCurve.Evaluate(normalizedValue);
            EditorGUILayout.LabelField($"{Constants.Attributes.AGI_SHORT}:\t{attr.FetchAtCurvePoint(targetCurveValue)}");

            targetCurveValue = entry.lckCurve.Evaluate(normalizedValue);
            EditorGUILayout.LabelField($"{Constants.Attributes.LCK_SHORT}:\t{attr.FetchAtCurvePoint(targetCurveValue)}");

            targetCurveValue = entry.defCurve.Evaluate(normalizedValue);
            EditorGUILayout.LabelField($"{Constants.Attributes.DEF_SHORT}:\t{attr.FetchAtCurvePoint(targetCurveValue)}");
            targetCurveValue = entry.resCurve.Evaluate(normalizedValue);
            EditorGUILayout.LabelField($"{Constants.Attributes.RES_SHORT}:\t{attr.FetchAtCurvePoint(targetCurveValue)}");

            EditorGUILayout.EndVertical();
            #endregion

            #region Weapons
            EditorGUILayout.BeginVertical("GroupBox", GUILayout.Width(350));
            BrightEditorGUILayout.LabelFieldBold("Weapon Type");
            entry.weaponTypeId = EditorGUILayout.IntPopup(entry.weaponTypeId, weaponTypeNames, weaponTypeIds);
            EditorGUILayout.EndVertical();
            #endregion

            #region Skills
            EditorGUILayout.BeginVertical("GroupBox", GUILayout.Width(350));
            skillUnlockVect = EditorGUILayout.BeginScrollView(skillUnlockVect, GUILayout.MinHeight(90));
            BrightEditorGUILayout.LabelFieldBold(Constants.SKILLS);
            if (entry.skills == null)
            {
                entry.skills = new System.Collections.Generic.List <SkillUnlockArgs>();
            }

            for (int i = 0; i < entry.skills.Count; i++)
            {
                var skillUnlockArgs = entry.skills[i];

                EditorGUI.indentLevel++;
                EditorGUILayout.BeginHorizontal();
                skillUnlockArgs.level   = EditorGUILayout.IntField(Constants.Attributes.LEVEL_SHORT, skillUnlockArgs.level);
                skillUnlockArgs.skillId = EditorGUILayout.IntPopup(skillUnlockArgs.skillId, skillNames, skillIds);
                if (GUILayout.Button("-", GUILayout.Width(20f)))
                {
                    entry.skills.RemoveAt(i);
                    break;
                }
                EditorGUILayout.EndHorizontal();
                EditorGUI.indentLevel--;
            }

            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("+", GUILayout.Width(40f)))
            {
                entry.skills.Add(new SkillUnlockArgs());
            }
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.EndScrollView();
            EditorGUILayout.EndVertical();
            #endregion

            EditorGUILayout.EndScrollView();
            EditorGUILayout.EndVertical();
        }
コード例 #14
0
    public override void OnInspectorGUI()
    {
        mFont = target as UIFont;
        NGUIEditorTools.SetLabelWidth(80f);

        GUILayout.Space(6f);

        if (mFont.replacement != null)
        {
            mType        = FontType.Reference;
            mReplacement = mFont.replacement;
        }
        else if (mFont.dynamicFont != null)
        {
            mType = FontType.Dynamic;
        }

        GUI.changed = false;
        GUILayout.BeginHorizontal();
        mType = (FontType)EditorGUILayout.EnumPopup("Font Type", mType);
        GUILayout.Space(18f);
        GUILayout.EndHorizontal();

        if (GUI.changed)
        {
            if (mType == FontType.Bitmap)
            {
                OnSelectFont(null);
            }

            if (mType != FontType.Dynamic && mFont.dynamicFont != null)
            {
                mFont.dynamicFont = null;
            }
        }

        if (mType == FontType.Reference)
        {
            ComponentSelector.Draw <UIFont>(mFont.replacement, OnSelectFont, true);

            GUILayout.Space(6f);
            EditorGUILayout.HelpBox("You can have one font simply point to " +
                                    "another one. This is useful if you want to be " +
                                    "able to quickly replace the contents of one " +
                                    "font with another one, for example for " +
                                    "swapping an SD font with an HD one, or " +
                                    "replacing an English font with a Chinese " +
                                    "one. All the labels referencing this font " +
                                    "will update their references to the new one.", MessageType.Info);

            if (mReplacement != mFont && mFont.replacement != mReplacement)
            {
                NGUIEditorTools.RegisterUndo("Font Change", mFont);
                mFont.replacement = mReplacement;
                NGUITools.SetDirty(mFont);
            }
            return;
        }
        else if (mType == FontType.Dynamic)
        {
#if UNITY_3_5
            EditorGUILayout.HelpBox("Dynamic fonts require Unity 4.0 or higher.", MessageType.Error);
#else
            Font fnt = EditorGUILayout.ObjectField("TTF Font", mFont.dynamicFont, typeof(Font), false) as Font;

            if (fnt != mFont.dynamicFont)
            {
                NGUIEditorTools.RegisterUndo("Font change", mFont);
                mFont.dynamicFont = fnt;
            }

            Material mat = EditorGUILayout.ObjectField("Material", mFont.material, typeof(Material), false) as Material;

            if (mFont.material != mat)
            {
                NGUIEditorTools.RegisterUndo("Font Material", mFont);
                mFont.material = mat;
            }

            GUILayout.BeginHorizontal();
            int       size  = EditorGUILayout.IntField("Default Size", mFont.defaultSize, GUILayout.Width(120f));
            FontStyle style = (FontStyle)EditorGUILayout.EnumPopup(mFont.dynamicFontStyle);
            GUILayout.Space(18f);
            GUILayout.EndHorizontal();

            if (size != mFont.defaultSize)
            {
                NGUIEditorTools.RegisterUndo("Font change", mFont);
                mFont.defaultSize = size;
            }

            if (style != mFont.dynamicFontStyle)
            {
                NGUIEditorTools.RegisterUndo("Font change", mFont);
                mFont.dynamicFontStyle = style;
            }
#endif
        }
        else
        {
            ComponentSelector.Draw <UIAtlas>(mFont.atlas, OnSelectAtlas, true);

            if (mFont.atlas != null)
            {
                if (mFont.bmFont.isValid)
                {
                    NGUIEditorTools.DrawAdvancedSpriteField(mFont.atlas, mFont.spriteName, SelectSprite, false);
                }
                EditorGUILayout.Space();
            }
            else
            {
                // No atlas specified -- set the material and texture rectangle directly
                Material mat = EditorGUILayout.ObjectField("Material", mFont.material, typeof(Material), false) as Material;

                if (mFont.material != mat)
                {
                    NGUIEditorTools.RegisterUndo("Font Material", mFont);
                    mFont.material = mat;
                }
            }

            // For updating the font's data when importing from an external source, such as the texture packer
            bool resetWidthHeight = false;

            if (mFont.atlas != null || mFont.material != null)
            {
                TextAsset data = EditorGUILayout.ObjectField("Import Data", null, typeof(TextAsset), false) as TextAsset;

                if (data != null)
                {
                    NGUIEditorTools.RegisterUndo("Import Font Data", mFont);
                    BMFontReader.Load(mFont.bmFont, NGUITools.GetHierarchy(mFont.gameObject), data.bytes);
                    mFont.MarkAsChanged();
                    resetWidthHeight = true;
                    GameDebug.Log("Imported " + mFont.bmFont.glyphCount + " characters");
                }
            }

            if (mFont.bmFont.isValid)
            {
                Texture2D tex = mFont.texture;

                if (tex != null && 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
                    pixels = EditorGUILayout.RectField("Pixel Rect", pixels);

                    // Convert the pixel coordinates back to UV coordinates
                    Rect uvRect = NGUIMath.ConvertToTexCoords(pixels, tex.width, tex.height);

                    if (mFont.uvRect != uvRect)
                    {
                        NGUIEditorTools.RegisterUndo("Font Pixel Rect", mFont);
                        mFont.uvRect = uvRect;
                    }
                    //NGUIEditorTools.DrawSeparator();
                    EditorGUILayout.Space();
                }
            }
        }

        // Dynamic fonts don't support emoticons
        if (!mFont.isDynamic && mFont.bmFont.isValid)
        {
            if (mFont.atlas != null)
            {
                if (NGUIEditorTools.DrawHeader("Symbols and Emoticons"))
                {
                    NGUIEditorTools.BeginContents();

                    List <BMSymbol> symbols = mFont.symbols;

                    for (int i = 0; i < symbols.Count;)
                    {
                        BMSymbol sym = symbols[i];

                        GUILayout.BeginHorizontal();
                        GUILayout.Label(sym.sequence, GUILayout.Width(40f));
                        if (NGUIEditorTools.DrawSpriteField(mFont.atlas, sym.spriteName, ChangeSymbolSprite, GUILayout.MinWidth(100f)))
                        {
                            mSelectedSymbol = sym;
                        }

                        if (GUILayout.Button("Edit", GUILayout.Width(40f)))
                        {
                            if (mFont.atlas != null)
                            {
                                NGUISettings.atlas          = mFont.atlas;
                                NGUISettings.selectedSprite = sym.spriteName;
                                NGUIEditorTools.Select(mFont.atlas.gameObject);
                            }
                        }

                        GUI.backgroundColor = Color.red;

                        if (GUILayout.Button("X", GUILayout.Width(22f)))
                        {
                            NGUIEditorTools.RegisterUndo("Remove symbol", mFont);
                            mSymbolSequence = sym.sequence;
                            mSymbolSprite   = sym.spriteName;
                            symbols.Remove(sym);
                            mFont.MarkAsChanged();
                        }
                        GUI.backgroundColor = Color.white;
                        GUILayout.EndHorizontal();
                        GUILayout.Space(4f);
                        ++i;
                    }

                    if (symbols.Count > 0)
                    {
                        GUILayout.Space(6f);
                    }

                    GUILayout.BeginHorizontal();
                    mSymbolSequence = EditorGUILayout.TextField(mSymbolSequence, GUILayout.Width(40f));
                    NGUIEditorTools.DrawSpriteField(mFont.atlas, mSymbolSprite, SelectSymbolSprite);

                    bool isValid = !string.IsNullOrEmpty(mSymbolSequence) && !string.IsNullOrEmpty(mSymbolSprite);
                    GUI.backgroundColor = isValid ? Color.green : Color.grey;

                    if (GUILayout.Button("Add", GUILayout.Width(40f)) && isValid)
                    {
                        NGUIEditorTools.RegisterUndo("Add symbol", mFont);
                        mFont.AddSymbol(mSymbolSequence, mSymbolSprite);
                        mFont.MarkAsChanged();
                        mSymbolSequence = "";
                        mSymbolSprite   = "";
                    }
                    GUI.backgroundColor = Color.white;
                    GUILayout.EndHorizontal();

                    if (symbols.Count == 0)
                    {
                        EditorGUILayout.HelpBox("Want to add an emoticon to your font? In the field above type ':)', choose a sprite, then hit the Add button.", MessageType.Info);
                    }
                    else
                    {
                        GUILayout.Space(4f);
                    }

                    NGUIEditorTools.EndContents();
                }
            }
        }

        if (mFont.bmFont != null && mFont.bmFont.isValid)
        {
            if (NGUIEditorTools.DrawHeader("Modify"))
            {
                NGUIEditorTools.BeginContents();

                UISpriteData sd = mFont.sprite;

                bool disable = (sd != null && (sd.paddingLeft != 0 || sd.paddingBottom != 0));
                EditorGUI.BeginDisabledGroup(disable || mFont.packedFontShader);

                EditorGUILayout.BeginHorizontal();
                GUILayout.Space(20f);
                EditorGUILayout.BeginVertical();

                GUILayout.BeginHorizontal();
                GUILayout.BeginVertical();
                NGUISettings.foregroundColor = EditorGUILayout.ColorField("Foreground", NGUISettings.foregroundColor);
                NGUISettings.backgroundColor = EditorGUILayout.ColorField("Background", NGUISettings.backgroundColor);
                GUILayout.EndVertical();
                mCurve = EditorGUILayout.CurveField("", mCurve, GUILayout.Width(40f), GUILayout.Height(40f));
                GUILayout.EndHorizontal();

                if (GUILayout.Button("Add a Shadow"))
                {
                    ApplyEffect(Effect.Shadow, NGUISettings.foregroundColor, NGUISettings.backgroundColor);
                }
                if (GUILayout.Button("Add a Soft Outline"))
                {
                    ApplyEffect(Effect.Outline, NGUISettings.foregroundColor, NGUISettings.backgroundColor);
                }
                if (GUILayout.Button("Rebalance Colors"))
                {
                    ApplyEffect(Effect.Rebalance, NGUISettings.foregroundColor, NGUISettings.backgroundColor);
                }
                if (GUILayout.Button("Apply Curve to Alpha"))
                {
                    ApplyEffect(Effect.AlphaCurve, NGUISettings.foregroundColor, NGUISettings.backgroundColor);
                }
                if (GUILayout.Button("Apply Curve to Foreground"))
                {
                    ApplyEffect(Effect.ForegroundCurve, NGUISettings.foregroundColor, NGUISettings.backgroundColor);
                }
                if (GUILayout.Button("Apply Curve to Background"))
                {
                    ApplyEffect(Effect.BackgroundCurve, NGUISettings.foregroundColor, NGUISettings.backgroundColor);
                }

                GUILayout.Space(10f);
                if (GUILayout.Button("Add Transparent Border (+1)"))
                {
                    ApplyEffect(Effect.Border, NGUISettings.foregroundColor, NGUISettings.backgroundColor);
                }
                if (GUILayout.Button("Remove Border (-1)"))
                {
                    ApplyEffect(Effect.Crop, NGUISettings.foregroundColor, NGUISettings.backgroundColor);
                }

                EditorGUILayout.EndVertical();
                GUILayout.Space(20f);
                EditorGUILayout.EndHorizontal();

                EditorGUI.EndDisabledGroup();

                if (disable)
                {
                    GUILayout.Space(3f);
                    EditorGUILayout.HelpBox("The sprite used by this font has been trimmed and is not suitable for modification. " +
                                            "Try re-adding this sprite with 'Trim Alpha' disabled.", MessageType.Warning);
                }

                NGUIEditorTools.EndContents();
            }
        }

        // The font must be valid at this point for the rest of the options to show up
        if (mFont.isDynamic || mFont.bmFont.isValid)
        {
            if (mFont.atlas == null)
            {
                mView      = View.Font;
                mUseShader = false;
            }
        }

        // Preview option
        if (!mFont.isDynamic && mFont.atlas != null)
        {
            GUILayout.BeginHorizontal();
            {
                mView = (View)EditorGUILayout.EnumPopup("Preview", mView);
                GUILayout.Label("Shader", GUILayout.Width(45f));
                mUseShader = EditorGUILayout.Toggle(mUseShader, GUILayout.Width(20f));
            }
            GUILayout.EndHorizontal();
        }
    }
コード例 #15
0
        void OnGUI()
        {
            EditorGUILayout.Space();
            EditorGUILayout.LabelField("Simple IAP System comes with billing plugin dependent");
            EditorGUILayout.LabelField("packages. Which one would you like to use?");

            EditorGUILayout.Space();
            EditorGUILayout.LabelField("Please read the PDF documentation after importing.");
            EditorGUILayout.LabelField("Other links: Window > Simple IAP System > About.");

            GUILayout.Space(10);
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Prime31", GUILayout.Width(100));
            if (GUILayout.Button("Import"))
            {
                AssetDatabase.ImportPackage(packagesPath + "Prime31.unitypackage", true);
                DisableAutoOpen();
            }
            if (GUILayout.Button("?", GUILayout.Width(20)))
            {
                Application.OpenURL("https://www.assetstore.unity3d.com/#/publisher/270");
            }
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.Space();
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Stans Assets", GUILayout.Width(100));
            if (GUILayout.Button("Import"))
            {
                AssetDatabase.ImportPackage(packagesPath + "StansAssets.unitypackage", true);
                DisableAutoOpen();
            }
            if (GUILayout.Button("?", GUILayout.Width(20)))
            {
                Application.OpenURL("https://www.assetstore.unity3d.com/#/publisher/2256");
            }
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.Space();
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Unibill", GUILayout.Width(100));
            if (GUILayout.Button("Import"))
            {
                AssetDatabase.ImportPackage(packagesPath + "Unibill.unitypackage", true);
                DisableAutoOpen();
            }
            if (GUILayout.Button("?", GUILayout.Width(20)))
            {
                Application.OpenURL("https://www.assetstore.unity3d.com/#/content/5767");
            }
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.Space();
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("OpenIAB (free)", GUILayout.Width(100));
            if (GUILayout.Button("Import"))
            {
                AssetDatabase.ImportPackage(packagesPath + "OpenIAB.unitypackage", true);
                DisableAutoOpen();
            }
            if (GUILayout.Button("?", GUILayout.Width(20)))
            {
                Application.OpenURL("https://github.com/onepf/OpenIAB-Unity-Plugin");
            }
            EditorGUILayout.EndHorizontal();
        }
コード例 #16
0
    protected override void gui()
    {
        base.gui();

        SkeletonAnimation component = (SkeletonAnimation)target;

        if (!component.valid)
        {
            return;
        }

        //catch case where SetAnimation was used to set track 0 without using AnimationName
        if (Application.isPlaying)
        {
            TrackEntry currentState = component.state.GetCurrent(0);
            if (currentState != null)
            {
                if (component.AnimationName != animationName.stringValue)
                {
                    animationName.stringValue = currentState.Animation.Name;
                }
            }
        }


        // Animation name.
        {
            String[] animations = new String[component.skeleton.Data.Animations.Count + 1];
            animations[0] = "<None>";
            int animationIndex = 0;
            for (int i = 0; i < animations.Length - 1; i++)
            {
                String name = component.skeleton.Data.Animations[i].Name;
                animations[i + 1] = name;
                if (name == animationName.stringValue)
                {
                    animationIndex = i + 1;
                }
            }

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Animation", GUILayout.Width(EditorGUIUtility.labelWidth));
            animationIndex = EditorGUILayout.Popup(animationIndex, animations);
            EditorGUILayout.EndHorizontal();

            String selectedAnimationName = animationIndex == 0 ? null : animations[animationIndex];
            component.AnimationName   = selectedAnimationName;
            animationName.stringValue = selectedAnimationName;
        }
        EditorGUILayout.PropertyField(mainColor);
        EditorGUILayout.PropertyField(loop);
        EditorGUILayout.PropertyField(timeScale);
        component.timeScale = Math.Max(component.timeScale, 0);

        EditorGUILayout.Space();

        if (!isPrefab)
        {
            if (component.GetComponent <SkeletonUtility>() == null)
            {
                if (GUILayout.Button(new GUIContent("Add Skeleton Utility", SpineEditorUtilities.Icons.skeletonUtility), GUILayout.Height(30)))
                {
                    component.gameObject.AddComponent <SkeletonUtility>();
                }
            }
        }
    }
コード例 #17
0
        //-----------------------------------------------TaB GUI'S--------------------------------------------------------------------------------------
        private void ShowConfigGUI()
        {
            if (LocalConfigPresets.Count > 0)
            {
                EnableRename = true;
            }
            else
            {
                EnableRename = false;
            }

            //----------------------------------------//Header\\----------------------------------------------------------------------------------------
            #region Header
            EditorGUILayout.BeginHorizontal();            //------------------------------------This is a Horizontal Group.
            //Chequeo cuantos presets estan disponibles y los muestro, si no hay nada aún, Muestro "Empty".
            ConfirmIfAviablePresetsExist();
            PresetSelected = EditorGUILayout.Popup(PresetSelected, AviablePresets);
            if (GUILayout.Button("Add"))
            {
                var item = new ConfigPreset();
                item.isDefault = false;
                //string name = item.ConfigurationName;
                LocalConfigPresets.Add(item);
                if (LocalConfigPresets.Count - 1 >= 0)
                {
                    PresetSelected = LocalConfigPresets.Count - 1;
                }
                else
                {
                    PresetSelected = 0;
                }
                var editWindow = GetWindow <EditPreset>().ToEdit(item);
                HasBeenModified = true;
                editWindow.Show();
            }
            if (GUILayout.Button("Duplicate"))
            {
                LocalConfigPresets.Add(LocalConfigPresets[PresetSelected].Clone());
            }

            EditorGUI.BeginDisabledGroup(LocalConfigPresets[PresetSelected].isDefault);
            if (GUILayout.Button("Edit"))
            {
                var editWindow = GetWindow <EditPreset>();
                editWindow.ToEdit(LocalConfigPresets[PresetSelected]);
                HasBeenModified = true;
                editWindow.Show();
            }
            if (GUILayout.Button("Delete"))
            {
                LocalConfigPresets.Remove(LocalConfigPresets[PresetSelected]);
                if (LocalConfigPresets.Count - 1 >= 0)
                {
                    PresetSelected = LocalConfigPresets.Count - 1;
                }
                else
                {
                    PresetSelected = 0;
                }
                HasBeenModified = true;
                ConfirmIfAviablePresetsExist();
            }
            EditorGUI.EndDisabledGroup();

            EditorGUILayout.EndHorizontal();            //--------------------------------------Here ends a Horizontal Group.
            #endregion
            //-------------------------------------------//Body\\-----------------------------------------------------------------------------------------
            #region Body
            GUILayout.Space(3);
            HorizontalLine(Color.grey);
            HorizontalLine(Color.grey);
            GUILayout.Space(3);

            ConfigScrollPos = EditorGUILayout.BeginScrollView(ConfigScrollPos, false, false, new GUILayoutOption[] { GUILayout.Height(150) });
            if (LocalConfigPresets.Count > 0)
            {
                WritableConfigPresetsAviable = true;
                LocalFolderPresets           = LocalConfigPresets[PresetSelected].GetFolderPresets();
                foreach (var item in LocalConfigPresets[PresetSelected].GetFolderPresets())
                {
                    ShowFolderConfigSet(item);
                }
                if (FoldersToClear.Count > 0)
                {
                    ClearFolderList();
                }
            }
            else
            {
                WritableConfigPresetsAviable = false;
            }
            EditorGUILayout.EndScrollView();

            GUILayout.Space(3);
            HorizontalLine(Color.grey);
            HorizontalLine(Color.grey);
            GUILayout.Space(3);
            #endregion
            //-------------------------------------------//Bottom\\---------------------------------------------------------------------------------------
            #region Bottom
            EditorGUI.BeginDisabledGroup(!WritableConfigPresetsAviable);

            EditorGUILayout.PrefixLabel("Add New Folders", new GUIStyle()
            {
                fontStyle = FontStyle.Bold
            });
            EditorGUILayout.BeginHorizontal();            //------------------------------------This is a Horizontal Group.
            //---------------------------------------Creo un nuevo Preset de Carpeta---------------------------
            //EditorGUILayout.LabelField("New Folder name: ", GUILayout.Width(75));

            if (GUILayout.Button("Create New Folder"))
            {
                if (LocalConfigPresets.Count > 0)
                {
                    List <string> NewAviableExtentionList = new List <string> {
                        ".mat"
                    };                                                                                                                 //Guardamos la Lista de extensiones.
                    LocalConfigPresets[PresetSelected].AddFolderPreset(newFolderName, newFolderTypeSelected, NewAviableExtentionList); //Guardamos el preset de la carpeta.
                    LocalFolderPresets    = LocalConfigPresets[PresetSelected].GetFolderPresets();
                    newFolderName         = DefaultFolderName;                                                                         //Reseteamos la previsualizacion del nombre.
                    newFolderTypeSelected = 0;                                                                                         //Reseteamos la previsualizacion del tipo.

                    foreach (var preset in LocalConfigPresets)
                    {
                        foreach (var folder in preset.FolderPresets)
                        {
                            MonoBehaviour.print("Presets Creados -->" + " Preset: " + preset.ConfigurationName + "Carpeta: " + folder.FolderName);
                        }
                    }
                }
                HasBeenModified = true;
            }
            newFolderName = EditorGUILayout.TextField(newFolderName);
            if (FolderTypeOptions == null)
            {
                FolderTypeOptions = new string[] { "Empty" }
            }
            ;
            if (FolderTypeOptions != null)
            {
                newFolderTypeSelected = EditorGUILayout.Popup(newFolderTypeSelected, FolderTypeOptions);
            }

            EditorGUILayout.EndHorizontal();            //--------------------------------------Here ends a Horizontal Group.
            EditorGUI.EndDisabledGroup();
            #endregion
        }
コード例 #18
0
ファイル: EasyTouchInspector.cs プロジェクト: ZaK14120/ARS
    public override void OnInspectorGUI()
    {
        EasyTouch t = (EasyTouch)target;

        #region General properties
        EditorGUILayout.Space();
        t.enable = HTGuiTools.Toggle("Enable EasyTouch", t.enable, true);

        t.enableRemote = HTGuiTools.Toggle("Enable Unity Remote", t.enableRemote, true);


        EditorGUILayout.Space();

        #endregion

        #region Gui propertie
        t.showGuiInspector = HTGuiTools.BeginFoldOut("GUI compatibilty", t.showGuiInspector);
        if (t.showGuiInspector)
        {
            HTGuiTools.BeginGroup(); {
                // UGUI

                EditorGUILayout.Space();
                t.allowUIDetection = HTGuiTools.Toggle("Enable Unity UI detection", t.allowUIDetection, true);
                if (t.allowUIDetection)
                {
                    EditorGUI.indentLevel++;
                    t.enableUIMode       = HTGuiTools.Toggle("Unity UI compatibilty", t.enableUIMode, true);
                    t.autoUpdatePickedUI = HTGuiTools.Toggle("Auto update picked Unity UI", t.autoUpdatePickedUI, true);
                    EditorGUI.indentLevel--;
                }

                EditorGUILayout.Space();

                // NGUI
                t.enabledNGuiMode = HTGuiTools.Toggle("Enable NGUI compatibilty", t.enabledNGuiMode, true);

                if (t.enabledNGuiMode)
                {
                    //EditorGUI.indentLevel++;
                    HTGuiTools.BeginGroup(5);
                    {
                        // layers
                        serializedObject.Update();
                        SerializedProperty layers = serializedObject.FindProperty("nGUILayers");
                        EditorGUILayout.PropertyField(layers, false);
                        serializedObject.ApplyModifiedProperties();

                        // Camera

                        if (HTGuiTools.Button("Add camera", Color.green, 100, false))
                        {
                            t.nGUICameras.Add(null);
                        }

                        for (int i = 0; i < t.nGUICameras.Count; i++)
                        {
                            EditorGUILayout.BeginHorizontal();
                            if (HTGuiTools.Button("X", Color.red, 19))
                            {
                                t.nGUICameras.RemoveAt(i);
                                i--;
                            }
                            else
                            {
                                t.nGUICameras[i] = (Camera)EditorGUILayout.ObjectField("", t.nGUICameras[i], typeof(Camera), true);
                                EditorGUILayout.EndHorizontal();
                            }
                        }
                    } HTGuiTools.EndGroup();
                    //EditorGUI.indentLevel--;
                }
            } HTGuiTools.EndGroup();
        }


        #endregion

        #region Auto selection properties
        t.showSelectInspector = HTGuiTools.BeginFoldOut("Automatic selection", t.showSelectInspector);
        if (t.showSelectInspector)
        {
            HTGuiTools.BeginGroup(); {
                t.autoSelect = HTGuiTools.Toggle("Enable auto-select", t.autoSelect, true);
                if (t.autoSelect)
                {
                    EditorGUILayout.Space();

                    // 3d layer
                    serializedObject.Update();
                    SerializedProperty layers = serializedObject.FindProperty("pickableLayers3D");
                    EditorGUILayout.PropertyField(layers, true);
                    serializedObject.ApplyModifiedProperties();


                    t.autoUpdatePickedObject = HTGuiTools.Toggle("Auto update picked gameobject", t.autoUpdatePickedObject, true);
                    EditorGUILayout.Space();

                    //2D
                    t.enable2D = HTGuiTools.Toggle("Enable 2D collider", t.enable2D, true);
                    if (t.enable2D)
                    {
                        serializedObject.Update();
                        layers = serializedObject.FindProperty("pickableLayers2D");
                        EditorGUILayout.PropertyField(layers, true);
                        serializedObject.ApplyModifiedProperties();
                    }


                    // Camera
                    GUILayout.Space(5f);
                    HTGuiTools.BeginGroup(5);
                    {
                        if (HTGuiTools.Button("Add Camera", Color.green, 100))
                        {
                            t.touchCameras.Add(new ECamera(null, false));
                        }
                        for (int i = 0; i < t.touchCameras.Count; i++)
                        {
                            EditorGUILayout.BeginHorizontal();
                            if (HTGuiTools.Button("X", Color.red, 19))
                            {
                                t.touchCameras.RemoveAt(i);
                                i--;
                            }
                            if (i >= 0)
                            {
                                t.touchCameras[i].camera    = (Camera)EditorGUILayout.ObjectField("", t.touchCameras[i].camera, typeof(Camera), true, GUILayout.MinWidth(150));
                                t.touchCameras[i].guiCamera = EditorGUILayout.ToggleLeft("Gui", t.touchCameras[i].guiCamera, GUILayout.Width(50));
                                EditorGUILayout.EndHorizontal();
                            }
                        }
                    } HTGuiTools.EndGroup();
                }
            } HTGuiTools.EndGroup();
        }

        #endregion

        #region General gesture properties
        t.showGestureInspector = HTGuiTools.BeginFoldOut("General gesture properties", t.showGestureInspector);
        if (t.showGestureInspector)
        {
            HTGuiTools.BeginGroup(); {
                t.gesturePriority     = (EasyTouch.GesturePriority)EditorGUILayout.EnumPopup("Priority to", t.gesturePriority);
                t.StationaryTolerance = EditorGUILayout.FloatField("Stationary tolerance", t.StationaryTolerance);
                t.longTapTime         = EditorGUILayout.FloatField("Long tap time", t.longTapTime);

                EditorGUILayout.Space();

                t.doubleTapDetection = (EasyTouch.DoubleTapDetection)EditorGUILayout.EnumPopup("Double tap detection", t.doubleTapDetection);
                if (t.doubleTapDetection == EasyTouch.DoubleTapDetection.ByTime)
                {
                    t.doubleTapTime = EditorGUILayout.Slider("Double tap time", t.doubleTapTime, 0.15f, 0.4f);
                }

                EditorGUILayout.Space();

                t.swipeTolerance  = EditorGUILayout.FloatField("Swipe tolerance", t.swipeTolerance);
                t.alwaysSendSwipe = EditorGUILayout.Toggle("always sent swipe event", t.alwaysSendSwipe);
            } HTGuiTools.EndGroup();
        }

        #endregion

        #region 2 fingers gesture
        t.showTwoFingerInspector = HTGuiTools.BeginFoldOut("Two fingers gesture properties", t.showTwoFingerInspector);
        if (t.showTwoFingerInspector)
        {
            HTGuiTools.BeginGroup(); {
                t.enable2FingersGesture = HTGuiTools.Toggle("2 fingers gesture", t.enable2FingersGesture, true);

                if (t.enable2FingersGesture)
                {
                    EditorGUI.indentLevel++;

                    t.twoFingerPickMethod = (EasyTouch.TwoFingerPickMethod)EditorGUILayout.EnumPopup("Pick method", t.twoFingerPickMethod);

                    EditorGUILayout.Separator();

                    t.enable2FingersSwipe = HTGuiTools.Toggle("Enable swipe & drag", t.enable2FingersSwipe, true);

                    EditorGUILayout.Separator();

                    t.enablePinch = HTGuiTools.Toggle("Enable Pinch", t.enablePinch, true);
                    if (t.enablePinch)
                    {
                        t.minPinchLength = EditorGUILayout.FloatField("Min pinch length", t.minPinchLength);
                    }

                    EditorGUILayout.Separator();

                    t.enableTwist = HTGuiTools.Toggle("Enable twist", t.enableTwist, true);
                    if (t.enableTwist)
                    {
                        t.minTwistAngle = EditorGUILayout.FloatField("Min twist angle", t.minTwistAngle);
                    }

                    EditorGUI.indentLevel--;
                }
            } HTGuiTools.EndGroup();
        }

        #endregion

        #region Second Finger simulation
        t.showSecondFingerInspector = HTGuiTools.BeginFoldOut("Second finger simulation", t.showSecondFingerInspector);
        if (t.showSecondFingerInspector)
        {
            HTGuiTools.BeginGroup(); {
                t.enableSimulation = HTGuiTools.Toggle("Enable simulation", t.enableSimulation, true);

                EditorGUILayout.Space();

                if (t.enableSimulation)
                {
                    EditorGUI.indentLevel++;

                    if (t.secondFingerTexture == null)
                    {
                        t.secondFingerTexture = Resources.Load("secondFinger") as Texture;
                    }

                    t.secondFingerTexture = (Texture)EditorGUILayout.ObjectField("Texture", t.secondFingerTexture, typeof(Texture), true);
                    EditorGUILayout.HelpBox("Change the keys settings for a fash compilation, or if you want to change the keys", MessageType.Info);
                    t.twistKey = (KeyCode)EditorGUILayout.EnumPopup("Twist & pinch key", t.twistKey);
                    t.swipeKey = (KeyCode)EditorGUILayout.EnumPopup("Swipe key", t.swipeKey);

                    EditorGUI.indentLevel--;
                }
            } HTGuiTools.EndGroup();
        }

        #endregion

        if (GUI.changed)
        {
            EditorUtility.SetDirty(target);
                        #if UNITY_5_3_OR_NEWER
            EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
                        #endif
        }
    }
コード例 #19
0
ファイル: OVRLint.cs プロジェクト: Noshin531/oculus
    void OnGUI()
    {
        GUILayout.Label("OVR Performance Lint Tool", EditorStyles.boldLabel);
        if (GUILayout.Button("Refresh", EditorStyles.toolbarButton, GUILayout.ExpandWidth(false)))
        {
            RunCheck();
        }

        string lastCategory = "";

        mScrollPosition = EditorGUILayout.BeginScrollView(mScrollPosition);

        for (int x = 0; x < mRecords.Count; x++)
        {
            FixRecord record = mRecords[x];

            if (!record.category.Equals(lastCategory))              // new category
            {
                lastCategory = record.category;
                EditorGUILayout.Separator();
                EditorGUILayout.BeginHorizontal();
                GUILayout.Label(lastCategory, EditorStyles.label, GUILayout.Width(200));
                bool moreThanOne = (x + 1 < mRecords.Count && mRecords[x + 1].category.Equals(lastCategory));
                if (record.buttonNames != null && record.buttonNames.Length > 0)
                {
                    if (moreThanOne)
                    {
                        GUILayout.Label("Apply to all:", EditorStyles.label, GUILayout.Width(75));
                        for (int y = 0; y < record.buttonNames.Length; y++)
                        {
                            if (GUILayout.Button(record.buttonNames[y], EditorStyles.toolbarButton, GUILayout.Width(200)))
                            {
                                List <FixRecord> recordsToProcess = new List <FixRecord>();

                                for (int z = x; z < mRecords.Count; z++)
                                {
                                    FixRecord thisRecord = mRecords[z];
                                    bool      isLast     = false;
                                    if (z + 1 >= mRecords.Count || !mRecords[z + 1].category.Equals(lastCategory))
                                    {
                                        isLast = true;
                                    }

                                    if (!thisRecord.complete)
                                    {
                                        recordsToProcess.Add(thisRecord);
                                    }

                                    if (isLast)
                                    {
                                        break;
                                    }
                                }

                                UnityEngine.Object[] undoObjects = new UnityEngine.Object[recordsToProcess.Count];
                                for (int z = 0; z < recordsToProcess.Count; z++)
                                {
                                    undoObjects[z] = recordsToProcess[z].targetObject;
                                }
                                Undo.RecordObjects(undoObjects, record.category + " (Multiple)");
                                for (int z = 0; z < recordsToProcess.Count; z++)
                                {
                                    FixRecord thisRecord = recordsToProcess[z];
                                    thisRecord.fixMethod(thisRecord.targetObject, (z + 1 == recordsToProcess.Count), y);
                                    thisRecord.complete = true;
                                }
                            }
                        }
                    }
                }
                EditorGUILayout.EndHorizontal();
                if (moreThanOne || record.targetObject)
                {
                    GUILayout.Label(record.message);
                }
            }

            EditorGUILayout.BeginHorizontal();
            GUI.enabled = !record.complete;
            if (record.targetObject)
            {
                EditorGUILayout.ObjectField(record.targetObject, record.targetObject.GetType(), true);
            }
            else
            {
                GUILayout.Label(record.message);
            }
            if (record.buttonNames != null)
            {
                for (int y = 0; y < record.buttonNames.Length; y++)
                {
                    if (GUILayout.Button(record.buttonNames[y], EditorStyles.toolbarButton, GUILayout.Width(200)))
                    {
                        if (record.targetObject != null)
                        {
                            Undo.RecordObject(record.targetObject, record.category);
                        }
                        record.fixMethod(record.targetObject, true, y);
                        record.complete = true;
                    }
                }
            }
            GUI.enabled = true;
            EditorGUILayout.EndHorizontal();
        }

        EditorGUILayout.EndScrollView();
    }
コード例 #20
0
        void OnGUI()
        {
            var serializedTable = new UnityEditor.SerializedObject(_table);

            // Get all screens
            var displayInfo = MonitorHelper.GetDisplays();

            EditorGUILayout.BeginVertical();

            // Screen num box
            var displayInfoAvailable = displayInfo != null && displayInfo.Count > 0;

            var viewCountProperty = serializedTable.FindProperty("viewCount");

            if (!displayInfoAvailable)
            {
                EditorGUILayout.PropertyField(viewCountProperty, _textViewCount);
            }
            else
            {
                viewCountProperty.intValue = displayInfo.Count;
            }

            int viewCount = viewCountProperty.intValue;

            // View-display table
            var viewTable = serializedTable.FindProperty("viewTable");

            for (var i = 0; i < viewCount; i++)
            {
                EditorGUILayout.IntPopup(
                    viewTable.GetArrayElementAtIndex(i),
                    _optionLabels, _optionValues, _viewLabels[i]
                    );

                // display monitor info below dropdown
                if (displayInfoAvailable)
                {
                    EditorGUILayout.LabelField(displayInfo[i].displayDevice.DeviceString, EditorStyles.miniLabel);
                    EditorGUILayout.LabelField(displayInfo[i].MonitorArea.ToString() + ", scale: " + (displayInfo[i].scaleFactor * 100) + "%", EditorStyles.miniLabel);
                }
            }
            for (var i = viewCount; i < viewTable.arraySize; i++)
            {
                viewTable.GetArrayElementAtIndex(i).intValue = -1;
            }

            EditorGUILayout.Space();

            // Function buttons
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.Space();
            if (GUILayout.Button("Layout"))
            {
                LayoutViews();
            }
            EditorGUILayout.Space();
            if (GUILayout.Button("Close All"))
            {
                CloseAllViews();
            }
            EditorGUILayout.Space();
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.EndVertical();

            serializedTable.ApplyModifiedProperties();
        }
コード例 #21
0
        public override void OnInspectorGUI()
        {
            if (isValid)
            {
                EditorGUILayout.HelpBox("Please ensure your camera not controled by other scripts", MessageType.Warning, true);
                //Updates the object we are editing
                serializedObject.Update();

                //Quick reference to the Quicktakecutscenecontroller script
                SmoothMoveCamera q = target as SmoothMoveCamera;
                q.waitUntilFinished = EditorGUILayout.Toggle("等待播放结束开始下一个事件", q.waitUntilFinished);

                EditorGUILayout.BeginHorizontal();
                //Button to manually call the StartCutscene function, only if the game is in play mode
                if (GUILayout.Button("Play"))
                {
                    if (Application.isPlaying)
                    {
                        q.ActivateCutscene();
                    }

                    if (!Application.isPlaying)
                    {
                        Debug.Log("You can only play the cutscene when the game is running");
                    }
                }
                //Button to manually call the StartCutscene function, only if the game is in play mode
                if (GUILayout.Button("Stop"))
                {
                    if (Application.isPlaying)
                    {
                        q.EndCutscene();
                    }

                    if (!Application.isPlaying)
                    {
                        Debug.Log("You can only play/stop the cutscene when the game is running");
                    }
                }
                EditorGUILayout.EndHorizontal();

                EditorGUILayout.BeginHorizontal();

                if (GUILayout.Button("Toggle Path (" + q.showPathType.GetHashCode() + ")"))
                {
                    q.ToggleShowPath();
                }

                if (GUILayout.Button("Add camera point"))
                {
                    GameObject g = new GameObject();
                    g.transform.position = (Selection.activeTransform.position + Random.insideUnitSphere * 5f);
                    g.transform.rotation = Selection.activeTransform.rotation;
                    g.transform.parent   = Selection.activeTransform;
                    string n = ("CameraPoint_" + numberOfEvents.ToString());
                    g.name = n;
                    Undo.RegisterCreatedObjectUndo(g, n);
                    this.OnEnable();
                }

                EditorGUILayout.EndHorizontal();

                EditorGUILayout.BeginHorizontal();
                //Camera selector
                EditorGUILayout.LabelField(cameraContent);
                q.mainCutsceneCam = EditorGUILayout.ObjectField(q.mainCutsceneCam, typeof(Camera), true) as Camera;
                EditorGUILayout.EndHorizontal();

                EditorGUILayout.Space();

                //Use delta time
                //EditorGUILayout.BeginHorizontal();
                //q.useDeltaTime = EditorGUILayout.Toggle(deltaTimeContent, q.useDeltaTime);
                //EditorGUILayout.EndHorizontal();

                EditorGUILayout.Space();

                //This for loop controls the display of each camera transition event, and the variables relating to it.
                for (int i = 0; i < (numberOfEvents - 2); i++)
                {
                    //Handle error which occurs when we undo a deleted CP
                    if (!points[i + 2])
                    {
                        this.OnEnable();
                    }
                    else
                    {
                        GUIContent popoutContent = new GUIContent("Camera transition " + (i + 1) + " --> " + (i + 2) + "     (" + points[i + 1].name + " -> " + points[i + 2].name + ")");
                        showEvent[i] = EditorGUILayout.Foldout(showEvent[i], popoutContent);//"Camera transition " + (i+1) + " --> " + (i+2));
                    }

                    if (showEvent[i] == true)
                    {
                        if (i >= q.cutsceneEventKeyTime.Length)
                        {
                            //Debug.Log("Refreshing Editor GUI");
                            //EditorGUIUtility.ExitGUI();
                            this.OnEnable();
                        }
                        q.cutsceneEventKeyTime[i] = EditorGUILayout.FloatField(delayContent, q.cutsceneEventKeyTime[i]);

                        //EditorGUILayout.Space();

                        q.cutsceneCameraSpeedOptions[i] = (CameraSpeedOptions)EditorGUILayout.EnumPopup(moveContent, q.cutsceneCameraSpeedOptions[i]);

                        if (q.cutsceneCameraSpeedOptions[i] == CameraSpeedOptions.Curve || q.cutsceneCameraSpeedOptions[i] == CameraSpeedOptions.MobileCurve)
                        {
                            q.curveChoice[i] = true;

                            EditorGUILayout.BeginHorizontal();

                            q.lerpCurveChoice[i] = EditorGUILayout.Toggle(lerpCurveContent, q.lerpCurveChoice[i]);

                            EditorGUILayout.EndHorizontal();

                            if (q.lerpCurveChoice[i])
                            {
                                q.customCurveMovementSpeed[i] = EditorGUILayout.Slider("   >Time (sec)", q.customCurveMovementSpeed[i], 0.0001f, 120f);
                            }
                            else
                            {
                                moveContent = new GUIContent("Movement ", "Movement speed options. Mobile curves require 1 mid-point, normal curves require 2 mid-points.");
                                EditorGUILayout.BeginHorizontal();
                                q.curveNodeCount[i] = EditorGUILayout.IntSlider(nodesContent, q.curveNodeCount[i], 10, 1000);
                                EditorGUILayout.EndHorizontal();
                                q.customCurveMovementSpeed[i] = EditorGUILayout.Slider(curveSpeedContent, q.customCurveMovementSpeed[i], 0.0001f, 120f);
                            }

                            EditorGUILayout.BeginHorizontal();
                            EditorGUILayout.LabelField(midPointContent);
                            EditorGUILayout.LabelField(midPoints[i + 1].name);
                            EditorGUILayout.EndHorizontal();
                            if (q.cutsceneCameraSpeedOptions[i] == CameraSpeedOptions.Curve)
                            {
                                EditorGUILayout.BeginHorizontal();
                                EditorGUILayout.LabelField(midPointTwoContent);
                                EditorGUILayout.LabelField(cubicPoints[i + 1].name);
                                EditorGUILayout.EndHorizontal();
                            }
                        }
                        else
                        {
                            q.curveChoice[i] = false;
                            moveContent      = new GUIContent("Movement ", "Camera positional movement speed during this event. (Units)");
                        }

                        //Custom movement speed
                        if (q.cutsceneCameraSpeedOptions[i] == CameraSpeedOptions.Custom)
                        {
                            q.customMovementSpeed[i] = EditorGUILayout.FloatField("   >Movement speed", q.customMovementSpeed[i]);
                        }

                        if (q.cutsceneCameraSpeedOptions[i] == CameraSpeedOptions.Lerp)
                        {
                            q.customMovementSpeed[i] = EditorGUILayout.FloatField("   >Movement time", q.customMovementSpeed[i]);
                        }

                        //EditorGUILayout.Space();

                        //Rotation speed
                        q.cutsceneCameraRotationSpeedOptions[i] = (CameraRotationSpeedOptions)EditorGUILayout.EnumPopup(rotationContent, q.cutsceneCameraRotationSpeedOptions[i]);
                        if (q.cutsceneCameraRotationSpeedOptions[i] == CameraRotationSpeedOptions.FollowTarget)
                        {
                            q.smoothFollowTarget[i] = (Transform)EditorGUILayout.ObjectField("   >Follow target", q.smoothFollowTarget[i], typeof(Transform), true) as Transform;
                        }

                        //Custom rotation speed
                        if (q.cutsceneCameraRotationSpeedOptions[i] == CameraRotationSpeedOptions.Custom)
                        {
                            q.customRotationSpeed[i] = EditorGUILayout.FloatField("   >Rotation speed", q.customRotationSpeed[i]);
                        }

                        //Custom rotation speed
                        if (q.cutsceneCameraRotationSpeedOptions[i] == CameraRotationSpeedOptions.Lerp)
                        {
                            q.customRotationSpeed[i] = EditorGUILayout.FloatField("   >Rotation time", q.customRotationSpeed[i]);
                        }

                        //EditorGUILayout.Space();

                        //Camera shake
                        q.doShake[i] = EditorGUILayout.Toggle("Shake camera ", q.doShake[i]);
                        if (q.doShake[i])
                        {
                            q.cameraShakeAmount[i] = EditorGUILayout.Slider("   >Shake intensity", q.cameraShakeAmount[i], 0.1f, 5f);
                        }

                        //EditorGUILayout.Space();

                        //time scale and broadcastmessage
                        q.cutsceneEventTimescale[i] = EditorGUILayout.Slider("Time scale", q.cutsceneEventTimescale[i], 0f, 2f);

                        //EditorGUILayout.Space();

                        q.broadcastMessageChoice[i] = EditorGUILayout.Toggle(broadcastContent, q.broadcastMessageChoice[i]);
                        if (q.broadcastMessageChoice[i] == true)
                        {
                            EditorGUILayout.BeginVertical();
                            q.broadcastMessageString[i] = EditorGUILayout.TextField("   >Method name", q.broadcastMessageString[i]);
                            q.broadcastMessageTarget[i] = EditorGUILayout.ObjectField("   >Target", q.broadcastMessageTarget[i], typeof(GameObject), true) as GameObject;
                            EditorGUILayout.EndVertical();
                        }

                        //EditorGUILayout.Space();

                        q.cutsceneEventZoom[i] = EditorGUILayout.Toggle(zoomContent, q.cutsceneEventZoom[i]);
                        if (q.cutsceneEventZoom[i] == true)
                        {
                            q.cutsceneEventZoomAmount[i] = EditorGUILayout.Slider("   >Field of View", q.cutsceneEventZoomAmount[i], 1f, 144f);
                            q.cutsceneEventZoomSpeed[i]  = EditorGUILayout.Slider("   >Zoom speed", q.cutsceneEventZoomSpeed[i], 0.001f, 40f);
                        }


                        //EditorGUILayout.EndVertical();
                    }
                }

                if (GUI.changed)
                {
                    EditorUtility.SetDirty(target);
                }

                //And apply
                serializedObject.ApplyModifiedProperties();
            }
        }
コード例 #22
0
        public override void OnInspectorGUI()
        {
            m_ScrollRect.Update();
            serializedObject.Update();

            EditorGUILayout.LabelField("格子大小");
            EditorGUILayout.PropertyField(m_CellWidth, new GUIContent("  宽度:"));
            m_CellWidth.intValue = m_CellWidth.intValue < 0 ? 0 : m_CellWidth.intValue;
            EditorGUILayout.PropertyField(m_CellHeight, new GUIContent("  高度:"));
            m_CellHeight.intValue = m_CellHeight.intValue < 0 ? 0 : m_CellHeight.intValue;

            EditorGUILayout.LabelField("偏移大小");
            EditorGUILayout.PropertyField(m_PaddingLeft, new GUIContent("  宽度:"));
            m_PaddingLeft.intValue = m_PaddingLeft.intValue < 0 ? 0 : m_PaddingLeft.intValue;
            EditorGUILayout.PropertyField(m_PaddingTop, new GUIContent("  高度:"));
            m_PaddingTop.intValue = m_PaddingTop.intValue < 0 ? 0 : m_PaddingTop.intValue;

            EditorGUILayout.Space();

            EditorGUILayout.LabelField("排序", GUILayout.Width(50));
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("  方向:", GUILayout.Width(116));
            EditorGUILayout.LabelField("水平", GUILayout.Width(26));
            if (EditorGUILayout.Toggle(m_Movement == 1, GUILayout.Width(40)) && m_Movement != 1)
            {
                m_Movement = 1;
            }

            EditorGUILayout.LabelField("垂直", GUILayout.Width(26));
            if (EditorGUILayout.Toggle(m_Movement == 2, GUILayout.Width(40)) && m_Movement != 2)
            {
                m_Movement = 2;
            }

            EditorGUILayout.EndHorizontal();
            m_ScrollRectHorizonta.boolValue = m_Movement == 1;
            m_ScrollRectVertical.boolValue  = m_Movement == 2;

            if (m_ScrollRectHorizonta.boolValue)
            {
                EditorGUILayout.PropertyField(m_GropVerticalValue, new GUIContent("  行数:"));
                m_GropVerticalValue.intValue = m_GropVerticalValue.intValue < 0 ? 0 : m_GropVerticalValue.intValue;
            }
            else
            {
                EditorGUILayout.PropertyField(m_GropHorizontalValue, new GUIContent("  列数:"));
                m_GropHorizontalValue.intValue = m_GropHorizontalValue.intValue < 0 ? 0 : m_GropHorizontalValue.intValue;
            }

            EditorGUILayout.Space();

            EditorGUILayout.LabelField("Tween");
            EditorGUILayout.PropertyField(m_MoveTweenSpeed, new GUIContent("  Speed:"));
            m_MoveTweenSpeed.intValue = m_MoveTweenSpeed.intValue < 0 ? 0 : m_MoveTweenSpeed.intValue;

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("编辑时试用:", GUILayout.Width(116));
            if (GUILayout.Button("排版"))
            {
                m_EasyScrollView.ResetPos();
            }

            EditorGUILayout.EndHorizontal();


            m_ScrollRect.ApplyModifiedProperties();
            serializedObject.ApplyModifiedProperties();
        }
コード例 #23
0
        public override void OnInspectorGUI()
        {
                                                                                                #if UNITY_5_6_OR_NEWER
            serializedObject.UpdateIfRequiredOrScript();
                                                                                                #else
            serializedObject.UpdateIfDirtyOrScript();
                                                                                                #endif

            if (sectionHeaderStyle == null)
            {
                sectionHeaderStyle = new GUIStyle(EditorStyles.foldout);
            }
            sectionHeaderStyle.normal.textColor = titleColor;
            sectionHeaderStyle.margin           = new RectOffset(12, 0, 0, 0);
            sectionHeaderStyle.fontStyle        = FontStyle.Bold;

            if (titleLabelStyle == null)
            {
                titleLabelStyle = new GUIStyle(EditorStyles.label);
            }
            titleLabelStyle.normal.textColor = titleColor;
            titleLabelStyle.fontStyle        = FontStyle.Bold;


            EditorGUILayout.Separator();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("General Settings", titleLabelStyle);
            if (GUILayout.Button("Help", GUILayout.Width(40)))
            {
                if (!EditorUtility.DisplayDialog("Dynamic Fog & Mist", "To learn more about a property in this inspector move the mouse over the label for a quick description (tooltip).\n\nPlease check README file in the root of the asset for details and contact support.\n\nIf you like Dynamic Fog & Mist, please rate it on the Asset Store. For feedback and suggestions visit our support forum on kronnect.com.", "Close", "Visit Support Forum"))
                {
                    Application.OpenURL("http://kronnect.com/taptapgo");
                }
            }
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.PropertyField(sun, new GUIContent("Sun", "Assign a game object (a directional light acting as Sun for example) to make the fog color sync automatically with the Sun orientation and light intensity."));


            EditorGUILayout.Separator();
            expandSection [FOG_PROPERTIES] = EditorGUILayout.Foldout(expandSection [FOG_PROPERTIES], sectionNames [FOG_PROPERTIES], sectionHeaderStyle);

            if (expandSection [FOG_PROPERTIES])
            {
                EditorGUILayout.PropertyField(alpha, new GUIContent("Alpha", "Global fog transparency. You can also change the transparency at color level."));
                EditorGUILayout.PropertyField(distance, new GUIContent("Distance", "The starting distance of the fog measure in linear 0-1 values (0=camera near clip, 1=camera far clip)."));
                EditorGUILayout.PropertyField(distanceFallOff, new GUIContent("Distance Fall Off", "Makes the fog appear smoothly on the near distance."));
                EditorGUILayout.PropertyField(height, new GUIContent("Height", "Height of the fog in meters."));
                EditorGUILayout.PropertyField(heightFallOff, new GUIContent("Height Fall Off", "Increase to make the fog change gradually its density based on height."));
                EditorGUILayout.PropertyField(baselineHeight, new GUIContent("Baseline Height", "Vertical position of the fog in meters. Height is counted above this baseline height."));
                EditorGUILayout.PropertyField(color);
            }
            EditorGUILayout.Separator();

            if (serializedObject.ApplyModifiedProperties() || (Event.current.type == EventType.ExecuteCommand && Event.current.commandName == "UndoRedoPerformed"))
            {
                DynamicFogManager fog = (DynamicFogManager)target;
                fog.UpdateMaterialProperties();
            }
        }
コード例 #24
0
        public override void OnInspectorGUI () {
            serObj.Update();

            GUILayout.Label("HDR " + (hdr.enumValueIndex == 0 ? "auto detected, " : (hdr.enumValueIndex == 1 ? "forced on, " : "disabled, ")) + (useSrcAlphaAsMask.floatValue < 0.1f ? " ignoring alpha channel glow information" : " using alpha channel glow information"), EditorStyles.miniBoldLabel);

            EditorGUILayout.PropertyField (tweakMode, new GUIContent("Tweak mode"));
            EditorGUILayout.PropertyField (screenBlendMode, new GUIContent("Blend mode"));
            EditorGUILayout.PropertyField (hdr, new GUIContent("HDR"));

            // display info text when screen blend mode cannot be used
            var bloomAndFlares = target as BloomAndFlares;
            if (bloomAndFlares != null)
            {
                Camera cam = bloomAndFlares.GetComponent<Camera>();
                if (cam != null) {
                    if (screenBlendMode.enumValueIndex==0 && ((cam.allowHDR && hdr.enumValueIndex==0) || (hdr.enumValueIndex==1))) {
                        EditorGUILayout.HelpBox("Screen blend is not supported in HDR. Using 'Add' instead.", MessageType.Info);
                    }
                }
            }

            if (1 == tweakMode.intValue)
                EditorGUILayout.PropertyField (lensflares, new GUIContent("Cast lens flares"));

            EditorGUILayout.Separator ();

            EditorGUILayout.PropertyField (bloomIntensity, new GUIContent("Intensity"));
            bloomthreshold.floatValue = EditorGUILayout.Slider ("threshold", bloomthreshold.floatValue, -0.05f, 4.0f);
            bloomBlurIterations.intValue = EditorGUILayout.IntSlider ("Blur iterations", bloomBlurIterations.intValue, 1, 4);
            sepBlurSpread.floatValue = EditorGUILayout.Slider ("Blur spread", sepBlurSpread.floatValue, 0.1f, 10.0f);

            if (1 == tweakMode.intValue)
                useSrcAlphaAsMask.floatValue = EditorGUILayout.Slider (new  GUIContent("Use alpha mask", "Make alpha channel define glowiness"), useSrcAlphaAsMask.floatValue, 0.0f, 1.0f);
            else
                useSrcAlphaAsMask.floatValue = 0.0f;

            if (1 == tweakMode.intValue) {
                EditorGUILayout.Separator ();

                if (lensflares.boolValue) {

                    // further lens flare tweakings
                    if (0 != tweakMode.intValue)
                        EditorGUILayout.PropertyField (lensflareMode, new GUIContent("Lens flare mode"));
                    else
                        lensflareMode.enumValueIndex = 0;

                    EditorGUILayout.PropertyField(lensFlareVignetteMask, new GUIContent("Lens flare mask", "This mask is needed to prevent lens flare artifacts"));

                    EditorGUILayout.PropertyField (lensflareIntensity, new GUIContent("Local intensity"));
                    lensflarethreshold.floatValue = EditorGUILayout.Slider ("Local threshold", lensflarethreshold.floatValue, 0.0f, 1.0f);

                    if (lensflareMode.intValue == 0) {
                        // ghosting
                        EditorGUILayout.BeginHorizontal ();
                        EditorGUILayout.PropertyField (flareColorA, new GUIContent("1st Color"));
                        EditorGUILayout.PropertyField (flareColorB, new GUIContent("2nd Color"));
                        EditorGUILayout.EndHorizontal ();

                        EditorGUILayout.BeginHorizontal ();
                        EditorGUILayout.PropertyField (flareColorC, new GUIContent("3rd Color"));
                        EditorGUILayout.PropertyField (flareColorD, new GUIContent("4th Color"));
                        EditorGUILayout.EndHorizontal ();
                    }
                    else if (lensflareMode.intValue == 1) {
                        // hollywood
                        EditorGUILayout.PropertyField (hollyStretchWidth, new GUIContent("Stretch width"));
                        hollywoodFlareBlurIterations.intValue = EditorGUILayout.IntSlider ("Blur iterations", hollywoodFlareBlurIterations.intValue, 1, 4);

                        EditorGUILayout.PropertyField (flareColorA, new GUIContent("Tint Color"));
                    }
                    else if (lensflareMode.intValue == 2) {
                        // both
                        EditorGUILayout.PropertyField (hollyStretchWidth, new GUIContent("Stretch width"));
                        hollywoodFlareBlurIterations.intValue = EditorGUILayout.IntSlider ("Blur iterations", hollywoodFlareBlurIterations.intValue, 1, 4);

                        EditorGUILayout.BeginHorizontal ();
                        EditorGUILayout.PropertyField (flareColorA, new GUIContent("1st Color"));
                        EditorGUILayout.PropertyField (flareColorB, new GUIContent("2nd Color"));
                        EditorGUILayout.EndHorizontal ();

                        EditorGUILayout.BeginHorizontal ();
                        EditorGUILayout.PropertyField (flareColorC, new GUIContent("3rd Color"));
                        EditorGUILayout.PropertyField (flareColorD, new GUIContent("4th Color"));
                        EditorGUILayout.EndHorizontal ();
                    }
                }
            } else
                lensflares.boolValue = false; // disable lens flares in simple tweak mode

            serObj.ApplyModifiedProperties();
        }
コード例 #25
0
        private void DrawFileChanges()
        {
            var size   = EditorGUIUtility.singleLineHeight;
            var square = new GUILayoutOption[] {
                GUILayout.MinWidth(size), GUILayout.MinHeight(size),
                GUILayout.MaxWidth(size), GUILayout.MaxHeight(size)
            };
            var button = new GUILayoutOption[] {
                GUILayout.MinWidth(size * 2 - 4), GUILayout.MinHeight(size - 2),
                GUILayout.MaxWidth(size * 2 - 4), GUILayout.MaxHeight(size - 2)
            };

            EditorGUILayout.BeginHorizontal();
            all = EditorGUILayout.Toggle(all, square);
            var newAll = all;

            EditorGUILayout.LabelField(GUIContent.none, square);
            var oldFontStyle = GUI.skin.label.fontStyle;

            GUI.skin.label.fontStyle = FontStyle.Bold;
            GUILayout.Label("Path");
            GUI.skin.label.fontStyle = oldFontStyle;
            EditorGUILayout.EndHorizontal();

            // Remove toggle entries for files that are no longer changed
            var toRemove = new List <string>();

            toggled = toggled ?? new ToggledDictionary();
            foreach (var file in toggled.Dictionary.Keys)
            {
                if (!State.Files.Select(x => x.FilePath).Contains(file))
                {
                    toRemove.Add(file);
                }
            }
            foreach (var file in toRemove)
            {
                toggled.Dictionary.Remove(file);
            }

            foreach (var file in State.Files)
            {
                EditorGUILayout.BeginHorizontal();

                // Draw toggle
                if (all)
                {
                    newAll = EditorGUILayout.Toggle(all, square);
                }
                else
                {
                    if (!toggled.Dictionary.ContainsKey(file.FilePath))
                    {
                        toggled[file.FilePath] = false;
                    }
                    toggled[file.FilePath] =
                        EditorGUILayout.Toggle(toggled[file.FilePath], square);
                }

                // Draw change type image
                switch (file.State)
                {
                case FileStatus.DeletedFromIndex:
                case FileStatus.DeletedFromWorkdir:
                    GUILayout.Label(Content(ImageCache.Deleted, "This file has been deleted."), square);
                    break;

                case FileStatus.ModifiedInIndex:
                case FileStatus.ModifiedInWorkdir:
                case FileStatus.RenamedInIndex:
                case FileStatus.RenamedInWorkdir:
                case FileStatus.TypeChangeInIndex:
                case FileStatus.TypeChangeInWorkdir:
                    GUILayout.Label(Content(ImageCache.Modified, "This file has been modified."), square);
                    break;

                case FileStatus.NewInIndex:
                case FileStatus.NewInWorkdir:
                    GUILayout.Label(Content(ImageCache.Added, "This file has been added."), square);
                    break;

                case FileStatus.Ignored:
                    GUI.enabled = false;
                    break;
                }

                // Draw file label
                EditorGUILayout.LabelField(file.FilePath);

                EditorGUILayout.Space();

                if (GUILayout.Button(Content(ImageCache.X, "Discard Changes"), button))
                {
                    var msg = "Are you sure you want to discard the changes to " + file.FilePath + "?";
                    if (EditorUtility.DisplayDialog("Discard Changes?", msg, "Yes", "No"))
                    {
                        CheckoutFile(file.FilePath);
                    }
                }
                GUI.enabled = true;

                EditorGUILayout.EndHorizontal();
            }

            if (newAll != all)
            {
                all = newAll;
            }
        }
コード例 #26
0
        void OnGUI()
        {
            FindAndCacheReaktors();

            scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);

            GUILayout.Label("Reaktor List", EditorStyles.boldLabel);

            foreach (var reaktor in cachedReaktors)
            {
                EditorGUILayout.BeginHorizontal();

                // Slider
                if (EditorApplication.isPlaying)
                {
                    if (reaktor.IsOverridden)
                    {
                        // Already overridden: show the override value.
                        var value = EditorGUILayout.Slider(reaktor.name, reaktor.Override, 0, 1);
                        if (!reaktor.Bang)
                        {
                            reaktor.Override = value;
                        }
                    }
                    else
                    {
                        // Not overridden: show the output value and begin override when touched.
                        var value = EditorGUILayout.Slider(reaktor.name, reaktor.Output, 0, 1);
                        if (value != reaktor.Output)
                        {
                            reaktor.Override = value;
                        }
                    }
                }
                else
                {
                    // Not playing: show a dummy slider.
                    EditorGUILayout.Slider(reaktor.name, 0, 0, 1);
                }

                // Bang button
                if (GUILayout.RepeatButton("!", EditorStyles.miniButtonLeft, GUILayout.Width(18)))
                {
                    reaktor.Bang = true;
                }
                else if (reaktor.Bang && Event.current.type == EventType.Repaint)
                {
                    reaktor.Override = 0;
                }

                // Release/Select button
                if (reaktor.IsOverridden)
                {
                    if (GUILayout.Button("Release", EditorStyles.miniButtonRight, GUILayout.Width(46)))
                    {
                        reaktor.StopOverride();
                    }
                }
                else
                {
                    if (GUILayout.Button("Select", EditorStyles.miniButtonRight, GUILayout.Width(46)))
                    {
                        Selection.activeGameObject = reaktor.gameObject;
                    }
                }

                EditorGUILayout.EndHorizontal();
            }

            EditorGUILayout.EndScrollView();
        }
コード例 #27
0
        public override void OnInspectorGUI()
        {
            if (target == null)
            {
                return;
            }

            var proCamera2DPixelPerfect = (ProCamera2DPixelPerfect)target;

            if (proCamera2DPixelPerfect.ProCamera2D == null)
            {
                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
                return;
            }

            var isOrthographic = false;

#if PC2D_TK2D_SUPPORT
            if (proCamera2DPixelPerfect.ProCamera2D.Tk2dCam != null && proCamera2DPixelPerfect.ProCamera2D.Tk2dCam.CameraSettings.projection == tk2dCameraSettings.ProjectionType.Orthographic)
            {
                isOrthographic = true;
            }
            else
            {
#endif
            isOrthographic = proCamera2DPixelPerfect.ProCamera2D.GameCamera.orthographic;
#if PC2D_TK2D_SUPPORT
        }
#endif
            if (!isOrthographic)
            {
                EditorGUILayout.HelpBox("Pixel perfect only works with orthographic cameras!", MessageType.Error, true);
            }

            serializedObject.Update();

            // Show script link
            GUI.enabled = false;
            _script     = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
            GUI.enabled = true;

            // ProCamera2D
            _tooltip = new GUIContent("Pro Camera 2D", "");
            EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);

            EditorGUI.BeginChangeCheck();

            // Pixels per unit
            _tooltip = new GUIContent("Pixels per Unit", "How many pixels in a sprite correspond to one unit in the world");
            EditorGUILayout.PropertyField(serializedObject.FindProperty("PixelsPerUnit"), _tooltip);

#if PC2D_TK2D_SUPPORT
            if (proCamera2DPixelPerfect.GetComponent <tk2dCamera>() != null)
            {
                // Pixels per meter
                _tooltip = new GUIContent("TK2D Sprites PPM", "The pixels per meter value of your TK2D sprite collections.");
                EditorGUILayout.PropertyField(serializedObject.FindProperty("Tk2DPixelsPerMeter"), _tooltip);

                if (proCamera2DPixelPerfect.Tk2DPixelsPerMeter < 1f)
                {
                    proCamera2DPixelPerfect.Tk2DPixelsPerMeter = 1f;
                }
            }
#endif

            // Viewport auto-scale
            EditorGUILayout.BeginHorizontal();

            _tooltip = new GUIContent("Viewport AutoScale", "If not None, the camera will automatically calculate the best scale across all resolutions based on the art viewport.");
            EditorGUILayout.PropertyField(serializedObject.FindProperty("ViewportAutoScale"), _tooltip);

            // Viewport Scale
            if (proCamera2DPixelPerfect.ViewportAutoScale != AutoScaleMode.None)
            {
                GUI.enabled = false;
                EditorGUILayout.LabelField(proCamera2DPixelPerfect.CalculateViewportScale() + "x", GUILayout.MaxWidth(60));
                GUI.enabled = true;
            }

            EditorGUILayout.EndHorizontal();

            // Viewport size in pixels
            if (proCamera2DPixelPerfect.ViewportAutoScale != AutoScaleMode.None)
            {
                _tooltip = new GUIContent("Game Viewport (pixels)", "Set it that if the screen was of this size, each pixel on the screen would correspond to a pixel on your art. On a pixel-art game this probably has low values.");
                EditorGUILayout.PropertyField(serializedObject.FindProperty("TargetViewportSizeInPixels"), _tooltip);
            }

            // Zoom
            _tooltip = new GUIContent("Zoom", "The zoom level of the camera");
            EditorGUILayout.PropertyField(serializedObject.FindProperty("Zoom"), _tooltip);

            // Snap movement to grid
            EditorGUILayout.BeginHorizontal();
            _tooltip = new GUIContent("Snap Movement to Grid", "If checked, the the sprites will snap to the grid. Might create some stuttering on your camera targets, especially if you're using a large grid and a follow smoothness greater than zero.");
            EditorGUILayout.PropertyField(serializedObject.FindProperty("SnapMovementToGrid"), _tooltip);

            if (proCamera2DPixelPerfect.SnapMovementToGrid)
            {
                _tooltip = new GUIContent("Snap Camera", "If checked, the camera will also snap to the grid. If you notice some stuttering in your game elements try to leave this on.");
                EditorGUILayout.PropertyField(serializedObject.FindProperty("SnapCameraToGrid"), _tooltip);
            }
            EditorGUILayout.EndHorizontal();

            // Draw grid
            EditorGUILayout.BeginHorizontal();

            _tooltip = new GUIContent("Draw Grid", "If checked, the camera will draw a pixel grid. 'Gizmos' button must be enabled on the Game window.");
            EditorGUILayout.PropertyField(serializedObject.FindProperty("DrawGrid"), _tooltip);

            if (proCamera2DPixelPerfect.DrawGrid)
            {
                _tooltip = new GUIContent("Grid Color", "");
                EditorGUILayout.PropertyField(serializedObject.FindProperty("GridColor"), _tooltip);
            }

            EditorGUILayout.EndHorizontal();

            // Grid density warning
            if (proCamera2DPixelPerfect.DrawGrid && proCamera2DPixelPerfect.GridDensity < 4)
            {
                EditorGUILayout.HelpBox("Grid density is too high to draw, so we're skipping it to avoid performance issues with the editor.", MessageType.None, true);
            }

            // Save properties
            serializedObject.ApplyModifiedProperties();

            // Limit values
            if (proCamera2DPixelPerfect.PixelsPerUnit < 1f)
            {
                proCamera2DPixelPerfect.PixelsPerUnit = 1f;
            }

            if (proCamera2DPixelPerfect.TargetViewportSizeInPixels.x < 1)
            {
                proCamera2DPixelPerfect.TargetViewportSizeInPixels.x = 1;
            }

            if (proCamera2DPixelPerfect.TargetViewportSizeInPixels.y < 1)
            {
                proCamera2DPixelPerfect.TargetViewportSizeInPixels.y = 1;
            }

            // Resize camera
            if (EditorGUI.EndChangeCheck() || !Application.isPlaying)
            {
                proCamera2DPixelPerfect.ResizeCameraToPixelPerfect();
            }
        }
コード例 #28
0
        public override void OnInspectorGUI()
        {
            GUI.DrawTexture(new Rect(16, EditorGUILayout.GetControlRect().y - 16, 16, 16), LTEditor.editorIcon());

            LeanTweenVisual tween = target as LeanTweenVisual;

            EditorGUI.BeginChangeCheck();
            float   overallDelay = 0;
            bool    clicked, deleted;
            Vector3 vec;

            clicked = false;

            bool playOnStartBefore = tween.playOnStart;
            bool playOnStartNow    = EditorGUILayout.Toggle(new GUIContent("Play on Start", "Tweens won't start automatically, you can start them via code with .start()"), tween.playOnStart);

            if (playOnStartBefore != playOnStartNow)
            {
                Undo.RecordObject(tween, "Toggling play on start");
                tween.playOnStart = playOnStartNow;
            }

            EditorGUILayout.BeginHorizontal();

            tween.restartOnEnable = EditorGUILayout.Toggle(new GUIContent("Restart on enable", "When you enable the gameobject these set of tweens will start again"), tween.restartOnEnable);
            tween.repeat          = EditorGUILayout.Toggle(new GUIContent("Repeat All", "Repeat the whole set of tween groups once they finish"), tween.repeat);
            EditorGUILayout.EndHorizontal();
            if (tween.repeat)
            {
                tween.repeatDelay = EditorGUILayout.FloatField("All Delay", tween.repeatDelay);
                tween.repeatCount = EditorGUILayout.IntField("All Repeat Count", tween.repeatCount);
            }

            float addedGroupDelay = 0f;

            foreach (LeanTweenGroup group in tween.groupList)
            {
                EditorGUILayout.Space();

                GUI.color = LTEditor.shared.colorGroupName;
                EditorGUILayout.BeginHorizontal();

                group.foldout = EditorGUILayout.Foldout(group.foldout, "", LTEditor.shared.styleGroupFoldout);
                clicked       = GUILayout.Button("Group: " + group.name + " " + (group.startTime) + "s - " + (group.endTime) + "s", LTEditor.shared.styleGroupButton);
                GUI.color     = LTEditor.shared.colorDelete;
                deleted       = GUILayout.Button("Delete", LTEditor.shared.styleDeleteGroupButton);
                EditorGUILayout.EndHorizontal();
                GUI.color = Color.white;

                if (clicked)
                {
                    group.foldout = !group.foldout;
                }
                if (deleted)
                {
                    Undo.RecordObject(tween, "Removing group item");
                    tween.groupList.Remove(group);
                    break;
                }

                float addedTweenDelay = 0f;
                if (group.foldout)
                {
                    group.name = EditorGUILayout.TextField("Group Name", group.name);
                    EditorGUILayout.BeginHorizontal();
                    group.repeat = EditorGUILayout.Toggle("Group Repeat", group.repeat);
                    group.delay  = EditorGUILayout.FloatField("Group Delay", group.delay);
                    EditorGUILayout.EndHorizontal();

                    group.gameObject = EditorGUILayout.ObjectField("Group GameObject", group.gameObject, typeof(GameObject), true) as GameObject;
                    if (group.gameObject == null)                   // Should default to the current object
                    {
                        group.gameObject = tween.gameObject;
                    }
                    if (group.repeat)
                    {
                        group.repeatCount = EditorGUILayout.IntField("Group Repeat Count", group.repeatCount);
                    }

                    int i = 0;
                    foreach (LeanTweenItem item in group.itemList)
                    {
                        TweenAction a = (TweenAction)item.action;

                        EditorGUILayout.BeginHorizontal();
                        GUILayout.Space(15);

                        item.foldout = EditorGUILayout.Foldout(item.foldout, "Tween ");
                        GUI.color    = LTEditor.shared.colorTweenName;

                        int actionIndex = EditorGUILayout.Popup(LTVisualShared.actionIndex(item), LTVisualShared.methodLabels);

                        LTVisualShared.setActionIndex(item, actionIndex);

                        // clicked = GUILayout.Button(""+a + " " + ( group.delay + item.delay) + "s - " + ( group.delay + item.delay + item.duration) + "s");
                        GUI.color = LTEditor.shared.colorDelete;
                        deleted   = GUILayout.Button("Delete", LTEditor.shared.styleDeleteButton);
                        EditorGUILayout.EndHorizontal();
                        GUI.color = Color.white;


                        if (clicked)
                        {
                            item.foldout = !item.foldout;
                        }
                        if (deleted)
                        {
                            Undo.RecordObject(tween, "Removing tween item");
                            group.itemList.Remove(item);

                            break;
                        }

                        if (item.foldout)
                        {
                            a = item.action;
                            bool tweenTypeChanged = (int)item.action != item.actionLast;
                            if (tweenTypeChanged && item.actionLast >= 0)
                            {
                                // Setup with the helpful default values
                                // Debug.Log("Setting up to default values a:"+a);

                                /*item.to = Vector3.zero;
                                 * if((a>=TweenAction.MOVE_X && a<=TweenAction.MOVE_LOCAL_Z) || a==TweenAction.MOVE || a==TweenAction.MOVE_LOCAL)
                                 *      item.to = item.from = tween.gameObject.transform.position;
                                 * else if((a>=TweenAction.SCALE_X && a<=TweenAction.SCALE_Z) || a==TweenAction.SCALE)
                                 *      item.to = item.from = tween.gameObject.transform.localScale;
                                 #if !UNITY_4_3 && !UNITY_4_5
                                 * else if(a==TweenAction.CANVAS_MOVE)
                                 *      item.to = item.from = tween.gameObject.GetComponent<RectTransform>().anchoredPosition;
                                 * else if(a==TweenAction.CANVAS_SCALE)
                                 *      item.to = item.from = tween.gameObject.GetComponent<RectTransform>().localScale;
                                 #endif
                                 */
                            }
                            item.actionLast = (int)item.action;
                            // Debug.Log("a:"+a);

                            item.gameObject = EditorGUILayout.ObjectField("    GameObject", item.gameObject, typeof(GameObject), true, GUILayout.Width(250)) as GameObject;
                            if (item.gameObject == null)                           // Should default to the current object
                            {
                                item.gameObject = tween.gameObject;
                            }

                            // Path
                            bool isCurve = false;
                            if (a == TweenAction.MOVE_CURVED || a == TweenAction.MOVE_CURVED_LOCAL)
                            {
                                item.bezierPath = EditorGUILayout.ObjectField("    LeanTweenPath:", item.bezierPath, typeof(LeanTweenPath), true) as LeanTweenPath;

                                EditorGUILayout.BeginHorizontal();
                                change(ref item.orientToPath, EditorGUILayout.Toggle("    Orient to Path", item.orientToPath), tween, "Orient to path");
//								if(orientToPath!=item.orientToPath){
//									Undo.RecordObject(tween,"Orient to path");
//									item.orientToPath = orientToPath;
//								}
                                isCurve = true;

                                item.isPath2d = EditorGUILayout.Toggle("    2D Path", item.isPath2d);
                                EditorGUILayout.EndHorizontal();
                            }
                            else if (a == TweenAction.MOVE_SPLINE || a == TweenAction.MOVE_SPLINE_LOCAL)
                            {
                                item.splinePath   = EditorGUILayout.ObjectField("    LeanTweenPath:", item.splinePath, typeof(LeanTweenPath), true) as LeanTweenPath;
                                item.orientToPath = EditorGUILayout.Toggle("    Orient to Path", item.orientToPath);
                                isCurve           = true;
                            }

                            if (isCurve == false)
                            {
                                bool isVector = a == TweenAction.MOVE || a == TweenAction.MOVE_LOCAL || a == TweenAction.CANVAS_MOVE || a == TweenAction.ROTATE || a == TweenAction.ROTATE_LOCAL || a == TweenAction.SCALE || a == TweenAction.CANVAS_SCALE || a == TweenAction.CANVAS_SIZEDELTA || a == TweenAction.DELAYED_SOUND;
                                bool isColor  = a >= TweenAction.COLOR && a < TweenAction.CALLBACK;
                                bool isPlay   = a == TweenAction.CANVAS_PLAYSPRITE;
                                bool usesFrom = !isColor && !isPlay;

                                // From Values
                                EditorGUILayout.BeginHorizontal();
                                if (usesFrom)                                 // Not a Color tween
                                {
                                    EditorGUILayout.LabelField(new GUIContent("    From", "Specify where the tween starts from, otherwise it will start from it's current value"), GUILayout.Width(50));
                                    LeanTweenBetween between = EditorGUILayout.Toggle("", item.between == LeanTweenBetween.FromTo, GUILayout.Width(30)) ? LeanTweenBetween.FromTo : LeanTweenBetween.To;
                                    if (between != item.between)
                                    {
                                        Undo.RecordObject(tween, "Changing to from/to");
                                        item.between = between;
                                    }
                                }
                                if (item.between == LeanTweenBetween.FromTo)
                                {
                                    if (isVector)
                                    {
//										item.from = EditorGUILayout.Vector3Field("", item.from);
                                        change(ref item.from, EditorGUILayout.Vector3Field("", item.from), tween, "Changing from");
                                    }
                                    else if (isColor)
                                    {
                                    }
                                    else
                                    {
                                        vec   = Vector3.zero;
                                        vec.x = EditorGUILayout.FloatField("From", item.from.x);
                                        if (vec.x != item.from.x)
                                        {
                                            Undo.RecordObject(tween, "Setting new from value");
                                            item.from = vec;
                                        }
                                    }
                                }
                                EditorGUILayout.EndHorizontal();

                                // To Values
                                EditorGUILayout.BeginHorizontal();
                                if (isVector)
                                {
                                    EditorGUILayout.LabelField("    To", GUILayout.Width(85));
                                    change(ref item.to, EditorGUILayout.Vector3Field("", item.to), tween, "Changing vector3 to");
                                }
                                else if (isColor)
                                {
                                    EditorGUILayout.LabelField("    To", GUILayout.Width(85));
                                    change(ref item.colorTo, EditorGUILayout.ColorField("", item.colorTo), tween, "Change color to");
                                }
                                else if (isPlay)
                                {
                                    GUILayout.Space(24);
                                    item.spritesMaximized = EditorGUILayout.Foldout(item.spritesMaximized, "Sprites");
                                    if (item.spritesMaximized)
                                    {
                                        EditorGUILayout.LabelField("Add", GUILayout.Width(35));
                                        UnityEngine.Sprite sprite = EditorGUILayout.ObjectField("", null, typeof(UnityEngine.Sprite), true, GUILayout.Width(150)) as UnityEngine.Sprite;
                                        if (sprite != null)
                                        {
                                            Undo.RecordObject(tween, "Adding a sprite");
                                            item.sprites = add(item.sprites, sprite);
                                        }
                                        EditorGUILayout.Separator();
                                        EditorGUILayout.Separator();
                                        EditorGUILayout.Separator();
                                    }
                                }
                                else
                                {
                                    vec = Vector3.zero;
                                    EditorGUILayout.LabelField("    To", GUILayout.Width(85));
                                    float setToX = EditorGUILayout.FloatField("", item.to.x);
                                    if (setToX != vec.x)
                                    {
                                        Undo.RecordObject(tween, "Setting x to");
                                        vec.x   = setToX;
                                        item.to = vec;
                                    }
                                }
                                EditorGUILayout.EndHorizontal();

                                // Sprite List
                                if (isPlay && item.spritesMaximized)
                                {
                                    for (int j = 0; j < item.sprites.Length; j++)
                                    {
                                        EditorGUILayout.BeginHorizontal();
                                        EditorGUILayout.LabelField("        sprite" + j, GUILayout.Width(85));
                                        item.sprites[j] = EditorGUILayout.ObjectField("", item.sprites[j], typeof(UnityEngine.Sprite), true) as UnityEngine.Sprite;
                                        GUI.color       = LTEditor.shared.colorDelete;
                                        deleted         = GUILayout.Button("Delete", LTEditor.shared.styleDeleteButton);
                                        GUI.color       = Color.white;
                                        EditorGUILayout.EndHorizontal();

                                        if (deleted)
                                        {
                                            Undo.RecordObject(tween, "Removing sprite");
                                            item.sprites = remove(item.sprites, j);
                                            break;
                                        }
                                    }
                                }

                                if (a == TweenAction.ROTATE_AROUND || a == TweenAction.ROTATE_AROUND_LOCAL
                                                                #if !UNITY_4_3 && !UNITY_4_5
                                    || a == TweenAction.CANVAS_ROTATEAROUND || a == TweenAction.CANVAS_ROTATEAROUND_LOCAL
                                                                #endif
                                    )
                                {
                                    item.axis = ShowAxis("    Axis", item.axis);
                                }
                            }
                            EditorGUILayout.Space();

                            // Easing
                            if (a == TweenAction.DELAYED_SOUND)
                            {
                                change(ref item.audioClip, EditorGUILayout.ObjectField("    AudioClip:", item.audioClip, typeof(AudioClip), true) as AudioClip, tween, "set audio clip");
                            }
                            else
                            {
                                EditorGUILayout.BeginHorizontal();
                                EditorGUILayout.LabelField("    Easing", GUILayout.Width(80));

                                int easeIndex    = LTVisualShared.easeIndex(item);
                                int easeIndexNew = EditorGUILayout.Popup("", easeIndex, LTVisualShared.easeStrMapping, GUILayout.Width(128));
                                if (easeIndex != easeIndexNew)
                                {
                                    Undo.RecordObject(tween, "changing easing type");
                                    LTVisualShared.setEaseIndex(item, easeIndexNew);
                                }

                                EditorGUILayout.Separator();
                                EditorGUILayout.EndHorizontal();

                                if (item.ease == LeanTweenType.animationCurve)
                                {
                                    Undo.RecordObject(tween, "changing easing type anim curve");
                                    item.animationCurve = EditorGUILayout.CurveField("    Ease Curve", item.animationCurve);
                                }
                                EditorGUILayout.Space();
                            }
                            if (item.ease >= LeanTweenType.once && item.ease < LeanTweenType.animationCurve)
                            {
                                EditorGUILayout.LabelField(new GUIContent("   ERROR: You Specified a non-easing type", "Select a type with the value 'Ease' in front of it (or linear)"), EditorStyles.boldLabel);
                            }

                            // Speed

                            EditorGUILayout.BeginHorizontal();
                            change(ref item.useSpeed, EditorGUILayout.Toggle("    Use Speed", item.useSpeed), tween, "toggled use speed");
                            EditorGUILayout.EndHorizontal();

                            // Timing
                            if (i > 0)
                            {
                                change(ref item.alignWithPrevious, EditorGUILayout.Toggle(new GUIContent("    Align with Previous", "When you change the timing of a previous tween, this tween's timing will be adjusted to follow afterwards."), item.alignWithPrevious),
                                       tween, "toggle align with previous");
                            }
                            EditorGUILayout.BeginHorizontal();
                            if (i > 0 && item.alignWithPrevious)
                            {
                                change(ref item.delay, addedTweenDelay, tween, "change delay");
                                EditorGUILayout.LabelField("    Delay:   " + item.delay, GUILayout.Width(50));
                            }
                            else
                            {
                                EditorGUILayout.LabelField("    Delay", GUILayout.Width(50));
                                change(ref item.delay, EditorGUILayout.FloatField("", item.delay, GUILayout.Width(50)), tween, "change delay");
                            }

                            if (a == TweenAction.DELAYED_SOUND)
                            {
                                EditorGUILayout.LabelField("Volume", GUILayout.Width(50));
                                change(ref item.duration, EditorGUILayout.FloatField("", item.duration, GUILayout.Width(50)), tween, "change volume");
                            }
                            else if (a == TweenAction.CANVAS_PLAYSPRITE)
                            {
                                EditorGUILayout.LabelField("Frame Rate", GUILayout.Width(85));
                                change(ref item.frameRate, EditorGUILayout.FloatField("", item.frameRate, GUILayout.Width(50)), tween, "change volume");
                            }
                            else if (item.useSpeed)
                            {
                                EditorGUILayout.LabelField("Speed", GUILayout.Width(50));
                                change(ref item.speed, EditorGUILayout.FloatField("", item.speed, GUILayout.Width(50)), tween, "change speed");
                            }
                            else
                            {
                                EditorGUILayout.LabelField("Time", GUILayout.Width(50));
                                float newDuration = EditorGUILayout.FloatField("", item.duration, GUILayout.Width(50));
                                if (newDuration <= 0.0f)
                                {
                                    newDuration = 0.0001f;
                                }
                                change(ref item.duration, newDuration, tween, "change timing");
                            }
                            EditorGUILayout.Separator();
                            EditorGUILayout.EndHorizontal();



                            // Repeat
                            EditorGUILayout.Space();
                            EditorGUILayout.BeginHorizontal();
                            EditorGUILayout.LabelField("    Loops", GUILayout.Width(50));
                            change(ref item.doesLoop, EditorGUILayout.Toggle("", item.doesLoop, GUILayout.Width(50)), tween, "toggled does loop");

                            if (item.doesLoop)
                            {
                                EditorGUILayout.LabelField(new GUIContent("Repeat", "-1 repeats infinitely"), GUILayout.Width(50));
                                change(ref item.loopCount, EditorGUILayout.IntField(new GUIContent("", ""), item.loopCount, GUILayout.Width(50)), tween, "changed loop count");
                                EditorGUILayout.LabelField(new GUIContent("    Wrap", "How the tween repeats\nclamp: restart from beginning\npingpong: goes back and forth"), GUILayout.Width(50));
                                int index = item.loopType == LeanTweenType.pingPong ? 1 : 0;
                                index = EditorGUILayout.Popup("", index, new string[] { "Clamp", "Ping Pong" }, GUILayout.Width(70));
                                LeanTweenType newLoopType = index == 0 ? LeanTweenType.clamp : LeanTweenType.pingPong;
                                if (newLoopType != item.loopType)
                                {
                                    Undo.RecordObject(tween, "change loop type");
                                    item.loopType = newLoopType;
                                }
                            }
                            EditorGUILayout.EndHorizontal();

                            addedTweenDelay = item.duration + item.delay;

                            EditorGUILayout.Separator();
                            EditorGUILayout.Separator();

                            i++;
                        }
                    }
                    if (ShowLeftButton("+ Tween", LTEditor.shared.colorAddTween, 15))
                    {
                        Undo.RecordObject(tween, "adding another tween");
                        LeanTweenItem newItem = new LeanTweenItem(addedTweenDelay);
                        newItem.alignWithPrevious = true;
                        group.itemList.Add(newItem);
                    }
                    addedGroupDelay += addedTweenDelay;

                    EditorGUILayout.Separator();
                }
                overallDelay += group.endTime;
            }

            if (ShowLeftButton("+ Group", LTEditor.shared.colorAddGroup))
            {
                Undo.RecordObject(tween, "adding another group");
                // Debug.Log("adding group with delay:"+addedGroupDelay);
                tween.groupList.Add(new LeanTweenGroup(addedGroupDelay));
            }


            EditorGUILayout.Separator();
            EditorGUILayout.Separator();
            EditorGUILayout.LabelField("Generated C# Code", EditorStyles.boldLabel);
            if (Application.isPlaying == false)
            {
                scrollCodeViewPos = EditorGUILayout.BeginScrollView(scrollCodeViewPos, GUILayout.Height(150));

                EditorGUILayout.TextArea(tween.buildAllTweens(true), LTEditor.shared.styleCodeTextArea);

                EditorGUILayout.EndScrollView();
            }
            else
            {
                EditorGUILayout.LabelField("    Not available during runtime");
            }

            if (EditorGUI.EndChangeCheck())
            {
//				Debug.Log("Saving time:"+Time.time);
                //Undo.RecordObject(tween, "LeanTweenVisual change");
            }
        }
コード例 #29
0
        private void CameraCullingSettings(bool helpEnabled)
        {
            //Monitor for changes
            EditorGUI.BeginChangeCheck();

            GaiaSceneCullingProfile cullingProfile = m_profile.CullingProfile;

            m_editorUtils.Heading("TerrainCulling");
            EditorGUI.indentLevel++;
            m_profile.m_terrainCullingEnabled = m_editorUtils.Toggle("UseTerrainCulling", m_profile.m_terrainCullingEnabled, helpEnabled);
            EditorGUI.indentLevel--;

            EditorGUILayout.Space();
            m_editorUtils.Heading("CameraCulling");
            EditorGUI.indentLevel++;

            bool cullingEnabled = m_profile.m_enableLayerCulling;

            cullingEnabled = m_editorUtils.Toggle("EnableLayerCulling", cullingEnabled, helpEnabled);
            if (m_profile.m_enableLayerCulling != cullingEnabled)
            {
                m_profile.m_enableLayerCulling = cullingEnabled;
                if (Application.isPlaying)
                {
                    GaiaScenePlayer.UpdateCullingDistances();
                }
                else
                {
                    GaiaScenePlayer.ApplySceneSetup(cullingEnabled);
                }
            }
            if (m_profile.m_enableLayerCulling)
            {
                m_editorUtils.LabelField("GeneralSettings", EditorStyles.boldLabel);
                EditorGUI.indentLevel++;
                EditorGUILayout.BeginHorizontal();
                cullingProfile = (GaiaSceneCullingProfile)m_editorUtils.ObjectField("CullingProfile", cullingProfile, typeof(GaiaSceneCullingProfile), false);
                if (m_editorUtils.Button("NewProfile", GUILayout.MaxWidth(40f)))
                {
                    GaiaSceneCullingProfile profile = GaiaSceneCullingProfile.CreateCullingProfile();
                    cullingProfile           = AssetDatabase.LoadAssetAtPath <GaiaSceneCullingProfile>(AssetDatabase.GetAssetPath(profile));
                    m_profile.CullingProfile = cullingProfile;
                    GUIUtility.ExitGUI();
                }
                EditorGUILayout.EndHorizontal();
                m_editorUtils.InlineHelp("CullingProfile", helpEnabled);
                if (cullingProfile != m_profile.CullingProfile)
                {
                    m_profile.CullingProfile = cullingProfile;
                    if (cullingProfile != null)
                    {
                        GaiaScenePlayer.ApplySceneSetup(cullingProfile.m_applyToEditorCamera);
                    }
                }
#if GAIA_PRO_PRESENT
                if (ProceduralWorldsGlobalWeather.Instance == null)
                {
                    m_profile.m_sunLight = (Light)m_editorUtils.ObjectField("SunLight", m_profile.m_sunLight, typeof(Light), true, helpEnabled);
                    if (m_profile.m_sunLight == null)
                    {
                        m_profile.m_sunLight = GaiaUtils.GetMainDirectionalLight();
                    }
                }
#else
                m_profile.m_sunLight = (Light)m_editorUtils.ObjectField("SunLight", m_profile.m_sunLight, typeof(Light), true, helpEnabled);
                if (m_profile.m_sunLight == null)
                {
                    m_profile.m_sunLight = GaiaUtils.GetMainDirectionalLight();
                }
#endif

                if (m_profile.CullingProfile != null)
                {
                    m_profile.CullingProfile.m_applyToEditorCamera = m_editorUtils.Toggle("ApplyInEditor", m_profile.CullingProfile.m_applyToEditorCamera, helpEnabled);
                    m_profile.CullingProfile.m_realtimeUpdate      = m_editorUtils.Toggle("RealtimeUpdate", m_profile.CullingProfile.m_realtimeUpdate, helpEnabled);
                }
                EditorGUI.indentLevel--;

                if (m_profile.CullingProfile != null)
                {
                    //Objects
                    EditorGUILayout.Space();
                    m_editorUtils.LabelField("ObjectCullingSettings", EditorStyles.boldLabel);
                    EditorGUI.indentLevel++;
                    m_editorUtils.InlineHelp("ObjectCullingSettings", helpEnabled);
                    for (int i = 0; i < m_profile.CullingProfile.m_layerDistances.Length; i++)
                    {
                        string layerName = LayerMask.LayerToName(i);
                        if (!string.IsNullOrEmpty(layerName))
                        {
                            m_profile.CullingProfile.m_layerDistances[i] = EditorGUILayout.FloatField(string.Format("[{0}] {1}", i, layerName), m_profile.CullingProfile.m_layerDistances[i]);
                        }
                    }
                    EditorGUI.indentLevel--;

                    if (m_editorUtils.Button("RevertCullingToDefaults"))
                    {
                        m_profile.CullingProfile.UpdateCulling(m_gaiaSettings);
                        EditorUtility.SetDirty(m_profile.CullingProfile);
                    }

                    //Shadows
                    EditorGUILayout.Space();
                    m_editorUtils.LabelField("ShadowCullingSettings", EditorStyles.boldLabel);
                    EditorGUI.indentLevel++;
                    m_editorUtils.InlineHelp("ShadowCullingSettings", helpEnabled);
                    for (int i = 0; i < m_profile.CullingProfile.m_shadowLayerDistances.Length; i++)
                    {
                        string layerName = LayerMask.LayerToName(i);
                        if (!string.IsNullOrEmpty(layerName))
                        {
                            m_profile.CullingProfile.m_shadowLayerDistances[i] = EditorGUILayout.FloatField(string.Format("[{0}] {1}", i, layerName), m_profile.CullingProfile.m_shadowLayerDistances[i]);
                        }
                    }

                    EditorGUI.indentLevel--;

                    if (m_editorUtils.Button("RevertShadowToDefaults"))
                    {
                        m_profile.CullingProfile.UpdateShadow();
                        EditorUtility.SetDirty(m_profile.CullingProfile);
                    }

                    EditorGUI.indentLevel--;
                }

                //Check for changes, make undo record, make changes and let editor know we are dirty
                if (EditorGUI.EndChangeCheck())
                {
                    Undo.RecordObject(m_profile, "Made camera culling changes");
                    EditorUtility.SetDirty(m_profile);
                    if (m_profile.CullingProfile != null)
                    {
                        EditorUtility.SetDirty(m_profile.CullingProfile);
                        if (Application.isPlaying)
                        {
                            GaiaScenePlayer.UpdateCullingDistances();
                        }
                        else
                        {
                            GaiaScenePlayer.ApplySceneSetup(m_profile.CullingProfile.m_applyToEditorCamera);
                        }
                    }
                }
            }
        }
コード例 #30
0
        public void RenderField(AIInspectorState state)
        {
            var evt      = Event.current;
            var mousePos = evt.mousePosition;
            var boxStyle = new GUIStyle("Box");

            if (_reorderable && _dragging)
            {
                // don't let the mouse affect the X position of the rect being dragged
                mousePos.x = _draggedRect.x;
            }

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField(_label);
            EditorGUILayout.Separator();
            if (GUILayout.Button(SharedStyles.addTooltip, SharedStyles.BuiltIn.addButtonSmall))
            {
                AddNew(mousePos, state);
            }

            EditorGUILayout.EndHorizontal();

            var count = _editorItems.Count;

            if (count == 0)
            {
                return;
            }

            EditorGUILayout.BeginVertical(boxStyle);

            var removeIdx = -1;

            if (!_reorderable || count <= 1)
            {
                for (int i = 0; i < count; i++)
                {
                    // if list is not reorderable, just draw items
                    EditorGUILayout.BeginVertical();
                    if (DrawEditorItem(_editorItems[i], state, false))
                    {
                        removeIdx = i;
                    }

                    EditorGUILayout.EndVertical();
                }
            }
            else
            {
                // Reorderable list
                int drawIdx = 0;
                for (int i = 0; i < count; i++)
                {
                    if (_dragging && _draggingIndex == drawIdx)
                    {
                        drawIdx++;
                    }

                    Rect dragHandle;
                    Rect itemRect;
                    if (i == _dropIndex)
                    {
                        dragHandle = new Rect();
                        itemRect   = EditorGUILayout.BeginVertical();
                        GUILayout.Space(_dragRectHeight);
                        EditorGUILayout.EndVertical();
                    }
                    else
                    {
                        itemRect = EditorGUILayout.BeginVertical();
                        var item = _editorItems[drawIdx++];
                        if (DrawEditorItem(item, state, true))
                        {
                            removeIdx = i;
                        }

                        EditorGUILayout.EndVertical();

                        dragHandle = DrawDragHandle();
                    }

                    if (evt.button == MouseButton.left && evt.isMouse)
                    {
                        if (!_dragging)
                        {
                            if (dragHandle.Contains(mousePos) && evt.type == EventType.MouseDrag)
                            {
                                _dragging      = true;
                                _draggingIndex = _dropIndex = i;
                                _draggedRect   = itemRect;
                                _dragOffsetY   = itemRect.y - mousePos.y;
                                break;
                            }
                        }
                        else
                        {
                            if (itemRect.Contains(mousePos))
                            {
                                _dropIndex = i;
                                break;
                            }
                        }
                    }
                }

                if (_dragging && evt.type == EventType.MouseUp)
                {
                    if (_draggingIndex != _dropIndex)
                    {
                        _list.Reorder(_draggingIndex, _dropIndex);
                        _editorItems.Reorder(_draggingIndex, _dropIndex);
                        state.currentAIUI.undoRedo.Do(new ReorderOperation(_draggingIndex, _dropIndex, _list));
                        state.MarkDirty();

                        if (Application.isPlaying)
                        {
                            HandleVisualizerReorder(state, _draggingIndex, _dropIndex);
                        }
                    }

                    _dragging  = false;
                    _dropIndex = _draggingIndex = -1;
                }
            }

            EditorGUILayout.EndVertical();

            if (removeIdx >= 0 && DisplayHelper.ConfirmDelete("item"))
            {
                DoRemove(removeIdx, state);
                _editorItems.RemoveAt(removeIdx);
                state.MarkDirty();

                if (Application.isPlaying)
                {
                    HandleVisualizerRemove(state, removeIdx);
                }
            }

            if (_reorderable && _dragging)
            {
                if (evt.type == EventType.Layout || evt.type == EventType.Repaint)
                {
                    GUI.Box(new Rect(_draggedRect.x, mousePos.y + _dragOffsetY, _draggedRect.width, _dragRectHeight), _editorItems[_draggingIndex].name, boxStyle);
                    AIInspectorEditor.instance.Repaint();
                }
            }
        }