// I've seen a lot of ugly methods in Unity source code, but this is just.. OMG
        // The method is identical to the original, only non-delayed fields are replaced with their delayed versions where possible.
        // For SerializedPropertyType.Integer, there is also a ternary expression instead of a single LongField because a version of DelayedLongField doesn't exist.
        public static bool DefaultPropertyFieldDelayed(Rect position, SerializedProperty property, GUIContent label)
        {
            label = EditorGUI.BeginPropertyInternal(position, label, property);

            SerializedPropertyType type = property.propertyType;

            bool childrenAreExpanded = false;

            // Should we inline? All one-line vars as well as Vector2, Vector3, Rect and Bounds properties are inlined.
            if (!EditorGUI.HasVisibleChildFields(property))
            {
                switch (type)
                {
                case SerializedPropertyType.Integer:
                {
                    EditorGUI.BeginChangeCheck();

                    long newValue = property.longValue > Int32.MaxValue
                            ? EditorGUI.LongField(position, label, property.longValue)
                            : EditorGUI.DelayedIntField(position, label, property.intValue);

                    if (EditorGUI.EndChangeCheck())
                    {
                        property.longValue = newValue;
                    }
                    break;
                }

                case SerializedPropertyType.Float:
                {
                    EditorGUI.BeginChangeCheck();

                    // Necessary to check for float type to get correct string formatting for float and double.
                    bool   isFloat  = property.type == "float";
                    double newValue = isFloat ? EditorGUI.DelayedFloatField(position, label, property.floatValue) :
                                      EditorGUI.DelayedDoubleField(position, label, property.doubleValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.doubleValue = newValue;
                    }
                    break;
                }

                case SerializedPropertyType.String:
                {
                    EditorGUI.BeginChangeCheck();
                    string newValue = EditorGUI.DelayedTextField(position, label, property.stringValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.stringValue = newValue;
                    }
                    break;
                }

                case SerializedPropertyType.Boolean:
                {
                    EditorGUI.BeginChangeCheck();
                    bool newValue = EditorGUI.Toggle(position, label, property.boolValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.boolValue = newValue;
                    }
                    break;
                }

                case SerializedPropertyType.Color:
                {
                    EditorGUI.BeginChangeCheck();
                    Color newColor = EditorGUI.ColorField(position, label, property.colorValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.colorValue = newColor;
                    }
                    break;
                }

                case SerializedPropertyType.ArraySize:
                {
                    EditorGUI.BeginChangeCheck();
                    int newValue = EditorGUI.ArraySizeField(position, label, property.intValue, EditorStyles.numberField);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.intValue = newValue;
                    }
                    break;
                }

                case SerializedPropertyType.FixedBufferSize:
                {
                    EditorGUI.DelayedIntField(position, label, property.intValue);
                    break;
                }

                case SerializedPropertyType.Enum:
                {
                    EditorGUI.EnumPopup(position, property, label);
                    break;
                }

                case SerializedPropertyType.ObjectReference:
                {
                    EditorGUI.ObjectFieldInternal(position, property, null, label, EditorStyles.objectField);
                    break;
                }

                case SerializedPropertyType.LayerMask:
                {
                    EditorGUI.LayerMaskField(position, property, label);
                    break;
                }

                case SerializedPropertyType.Character:
                {
                    char[] value = { (char)property.intValue };

                    bool wasChanged = GUI.changed;
                    GUI.changed = false;
                    string newValue = EditorGUI.DelayedTextField(position, label, new string(value));
                    if (GUI.changed)
                    {
                        if (newValue.Length == 1)
                        {
                            property.intValue = newValue[0];
                        }
                        // Value didn't get changed after all
                        else
                        {
                            GUI.changed = false;
                        }
                    }
                    GUI.changed |= wasChanged;
                    break;
                }

                case SerializedPropertyType.AnimationCurve:
                {
                    int id = GUIUtility.GetControlID(EditorGUI.s_CurveHash, FocusType.Keyboard, position);
                    EditorGUI.DoCurveField(EditorGUI.PrefixLabel(position, id, label), id, null, EditorGUI.kCurveColor, new Rect(), property);
                    break;
                }

                case SerializedPropertyType.Gradient:
                {
                    int id = GUIUtility.GetControlID(EditorGUI.s_CurveHash, FocusType.Keyboard, position);
                    EditorGUI.DoGradientField(EditorGUI.PrefixLabel(position, id, label), id, null, property, false, ColorSpace.Gamma);
                    break;
                }

                case SerializedPropertyType.Vector3:
                {
                    EditorGUI.Vector3Field(position, property, label);
                    break;
                }

                case SerializedPropertyType.Vector4:
                {
                    EditorGUI.Vector4Field(position, property, label);
                    break;
                }

                case SerializedPropertyType.Vector2:
                {
                    EditorGUI.Vector2Field(position, property, label);
                    break;
                }

                case SerializedPropertyType.Vector2Int:
                {
                    EditorGUI.Vector2IntField(position, property, label);
                    break;
                }

                case SerializedPropertyType.Vector3Int:
                {
                    EditorGUI.Vector3IntField(position, property, label);
                    break;
                }

                case SerializedPropertyType.Rect:
                {
                    EditorGUI.RectField(position, property, label);
                    break;
                }

                case SerializedPropertyType.RectInt:
                {
                    EditorGUI.RectIntField(position, property, label);
                    break;
                }

                case SerializedPropertyType.Bounds:
                {
                    EditorGUI.BoundsField(position, property, label);
                    break;
                }

                case SerializedPropertyType.BoundsInt:
                {
                    EditorGUI.BoundsIntField(position, property, label);
                    break;
                }

                default:
                {
                    int genericID = GUIUtility.GetControlID(EditorGUI.s_GenericField, FocusType.Keyboard, position);
                    EditorGUI.PrefixLabel(position, genericID, label);
                    break;
                }
                }
            }
            // Handle Foldout
            else
            {
                Event tempEvent = new Event(Event.current);

                // Handle the actual foldout first, since that's the one that supports keyboard control.
                // This makes it work more consistent with PrefixLabel.
                childrenAreExpanded = property.isExpanded;

                bool newChildrenAreExpanded = childrenAreExpanded;
                using (new EditorGUI.DisabledScope(!property.editable))
                {
                    GUIStyle foldoutStyle = (DragAndDrop.activeControlID == -10) ? EditorStyles.foldoutPreDrop : EditorStyles.foldout;
                    newChildrenAreExpanded = EditorGUI.Foldout(position, childrenAreExpanded, EditorGUI.s_PropertyFieldTempContent, true, foldoutStyle);
                }


                if (childrenAreExpanded && property.isArray && property.arraySize > property.serializedObject.maxArraySizeForMultiEditing && property.serializedObject.isEditingMultipleObjects)
                {
                    Rect boxRect = position;
                    boxRect.xMin += EditorGUIUtility.labelWidth - EditorGUI.indent;

                    EditorGUI.s_ArrayMultiInfoContent.text = EditorGUI.s_ArrayMultiInfoContent.tooltip = string.Format(EditorGUI.s_ArrayMultiInfoFormatString, property.serializedObject.maxArraySizeForMultiEditing);
                    EditorGUI.LabelField(boxRect, GUIContent.none, EditorGUI.s_ArrayMultiInfoContent, EditorStyles.helpBox);
                }

                if (newChildrenAreExpanded != childrenAreExpanded)
                {
                    // Recursive set expanded
                    if (Event.current.alt)
                    {
                        EditorGUI.SetExpandedRecurse(property, newChildrenAreExpanded);
                    }
                    // Expand one element only
                    else
                    {
                        property.isExpanded = newChildrenAreExpanded;
                    }
                }
                childrenAreExpanded = newChildrenAreExpanded;


                // Check for drag & drop events here, to add objects to an array by dragging to the foldout.
                // The event may have already been used by the Foldout control above, but we want to also use it here,
                // so we use the event copy we made prior to calling the Foldout method.

                // We need to use last s_LastControlID here to ensure we do not break duplicate functionality (fix for case 598389)
                // If we called GetControlID here s_LastControlID would be incremented and would not longer be in sync with GUIUtililty.keyboardFocus that
                // is used for duplicating (See DoPropertyFieldKeyboardHandling)
                int id = EditorGUIUtility.s_LastControlID;
                switch (tempEvent.type)
                {
                case EventType.DragExited:
                    if (GUI.enabled)
                    {
                        HandleUtility.Repaint();
                    }

                    break;

                case EventType.DragUpdated:
                case EventType.DragPerform:

                    if (position.Contains(tempEvent.mousePosition) && GUI.enabled)
                    {
                        Object[] references = DragAndDrop.objectReferences;

                        // Check each single object, so we can add multiple objects in a single drag.
                        Object[] oArray        = new Object[1];
                        bool     didAcceptDrag = false;
                        foreach (Object o in references)
                        {
                            oArray[0] = o;
                            Object validatedObject = EditorGUI.ValidateObjectFieldAssignment(oArray, null, property, EditorGUI.ObjectFieldValidatorOptions.None);
                            if (validatedObject != null)
                            {
                                DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
                                if (tempEvent.type == EventType.DragPerform)
                                {
                                    property.AppendFoldoutPPtrValue(validatedObject);
                                    didAcceptDrag = true;
                                    DragAndDrop.activeControlID = 0;
                                }
                                else
                                {
                                    DragAndDrop.activeControlID = id;
                                }
                            }
                        }
                        if (didAcceptDrag)
                        {
                            GUI.changed = true;
                            DragAndDrop.AcceptDrag();
                        }
                    }
                    break;
                }
            }

            EditorGUI.EndProperty();

            return(childrenAreExpanded);
        }
示例#2
0
        public static bool DefaultPropertyField(Rect position, RuntimeSerializedProperty property, GUIContent label)
        {
            label = BeginProperty(position, label, property);

            System.Type propertyType = property.PropertyType;

            bool childrenAreExpanded = false;

            // Should we inline? All one-line vars as well as Vector2, Vector3, Rect and Bounds properties are inlined.
            if (!HasVisibleChildFields(property))
            {
                if (propertyType == RuntimeSerializedPropertyType.Bool)
                {
                    EditorGUI.BeginChangeCheck();
                    bool boolValue = EditorGUI.Toggle(position, label, property.BoolValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.BoolValue = boolValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.Byte)
                {
                    EditorGUI.BeginChangeCheck();
                    int intValue = EditorGUI.IntField(position, label, property.ByteValue);
                    if (intValue >= byte.MaxValue)
                    {
                        intValue = byte.MaxValue;
                    }
                    else if (intValue <= byte.MinValue)
                    {
                        intValue = byte.MinValue;
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.ByteValue = (byte)intValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.Char)
                {
                    char[] value = new char[] {
                        property.CharValue
                    };
                    bool changed = GUI.changed;
                    GUI.changed = false;
                    string text = EditorGUI.TextField(position, label, new string(value));
                    if (GUI.changed)
                    {
                        if (text.Length == 1)
                        {
                            property.CharValue = (char)text[0];
                        }
                        else
                        {
                            GUI.changed = false;
                        }
                    }
                    GUI.changed |= changed;
                }
                else if (propertyType == RuntimeSerializedPropertyType.Short)
                {
                    EditorGUI.BeginChangeCheck();
                    int intValue = EditorGUI.IntField(position, label, property.ShortValue);
                    if (intValue >= short.MaxValue)
                    {
                        intValue = short.MaxValue;
                    }
                    else if (intValue <= short.MinValue)
                    {
                        intValue = short.MinValue;
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.ShortValue = (short)intValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.Integer)
                {
                    EditorGUI.BeginChangeCheck();
                    int intValue = EditorGUI.IntField(position, label, property.IntValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.IntValue = intValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.Long)
                {
                    EditorGUI.BeginChangeCheck();
                    long longValue = EditorGUI.LongField(position, label, property.LongValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.LongValue = longValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.sByte)
                {
                    EditorGUI.BeginChangeCheck();
                    int intValue = EditorGUI.IntField(position, label, property.sByteValue);
                    if (intValue >= sbyte.MaxValue)
                    {
                        intValue = sbyte.MaxValue;
                    }
                    else if (intValue <= sbyte.MinValue)
                    {
                        intValue = sbyte.MinValue;
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.sByteValue = (sbyte)intValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.uShort)
                {
                    EditorGUI.BeginChangeCheck();
                    int intValue = EditorGUI.IntField(position, label, property.uShortValue);
                    if (intValue >= ushort.MaxValue)
                    {
                        intValue = ushort.MaxValue;
                    }
                    else if (intValue <= ushort.MinValue)
                    {
                        intValue = ushort.MinValue;
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.uShortValue = (ushort)intValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.uInteger)
                {
                    EditorGUI.BeginChangeCheck();
                    long longValue = EditorGUI.LongField(position, label, property.uIntValue);
                    if (longValue >= uint.MaxValue)
                    {
                        longValue = uint.MaxValue;
                    }
                    else if (longValue <= uint.MinValue)
                    {
                        longValue = uint.MinValue;
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.uIntValue = (uint)longValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.uLong)
                {
                    EditorGUI.BeginChangeCheck();
                    string stringValue = EditorGUI.TextField(position, label, property.uLongValue.ToString());
                    if (EditorGUI.EndChangeCheck())
                    {
                        ulong ulongValue = property.uLongValue;
                        if (ulong.TryParse(stringValue, out ulongValue))
                        {
                            property.uLongValue = ulongValue;
                        }
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.Float)
                {
                    EditorGUI.BeginChangeCheck();
                    float floatValue = EditorGUI.FloatField(position, label, property.FloatValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.FloatValue = floatValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.Double)
                {
                    EditorGUI.BeginChangeCheck();
                    double doubleValue = EditorGUI.DoubleField(position, label, property.DoubleValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.DoubleValue = doubleValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.String)
                {
                    EditorGUI.BeginChangeCheck();
                    string stringValue = EditorGUI.TextField(position, label, property.StringValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.StringValue = stringValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.Color)
                {
                    EditorGUI.BeginChangeCheck();
                    Color colorValue = EditorGUI.ColorField(position, label, property.ColorValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.ColorValue = colorValue;
                    }
                }
                else if (propertyType.IsSameOrSubclassOf(RuntimeSerializedPropertyType.Object))
                {
                    GUIStyle style = new GUIStyle();
                    style.richText = true;
                    EditorGUI.LabelField(position, "<color=red>Reference type is not supported!</color>", style);
                }
                else if (propertyType == RuntimeSerializedPropertyType.LayerMask)
                {
                    EditorGUI.BeginChangeCheck();
                    LayerMask layerMaskValue   = property.LayerMaskValue;
                    string[]  displayedOptions = RuntimeSerializedProperty.GetLayerMaskNames(0);
                    int       num = EditorGUI.MaskField(position, label, layerMaskValue.value, displayedOptions);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.LayerMaskValue = num;
                    }
                }
                else if (propertyType.IsEnum)
                {
                    EditorGUI.BeginChangeCheck();
                    System.Enum enumValue = EditorGUI.EnumPopup(position, label, property.EnumValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.EnumValue = enumValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.Vector2)
                {
                    EditorGUI.BeginChangeCheck();
                    Vector2 vector2Value = EditorGUI.Vector2Field(position, label, property.Vector2Value);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.Vector2Value = vector2Value;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.Vector3)
                {
                    EditorGUI.BeginChangeCheck();
                    Vector3 vector3Value = EditorGUI.Vector3Field(position, label, property.Vector3Value);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.Vector3Value = vector3Value;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.Vector4)
                {
                    EditorGUI.BeginChangeCheck();
                    Vector4 vector4Value = EditorGUI.Vector4Field(position, label, property.Vector4Value);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.Vector4Value = vector4Value;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.Rect)
                {
                    EditorGUI.BeginChangeCheck();
                    Rect rectValue = EditorGUI.RectField(position, label, property.RectValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.RectValue = rectValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.ArraySize)
                {
                    EditorGUI.BeginChangeCheck();
                    int intValue = EasyGUI.ArraySizeField(position, label, property.ArraySize, EditorStyles.numberField);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.ArraySize = intValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.AnimationCurve)
                {
                    EditorGUI.BeginChangeCheck();
                    if (property.AnimationCurveValue == null)
                    {
                        property.AnimationCurveValue = new AnimationCurve(new Keyframe[] {
                            new Keyframe(0, 1),
                            new Keyframe(1, 1)
                        });
                    }
                    AnimationCurve animationCurveValue = EditorGUI.CurveField(position, label, property.AnimationCurveValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.AnimationCurveValue = animationCurveValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.Bounds)
                {
                    EditorGUI.BeginChangeCheck();
                    Bounds boundsValue = EditorGUI.BoundsField(position, label, property.BoundsValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.BoundsValue = boundsValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.Gradient)
                {
                    EditorGUI.BeginChangeCheck();
                    Gradient gradientValue = EasyGUI.GradientField(label, position, property.GradientValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.GradientValue = gradientValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.FixedBufferSize)
                {
                    EditorGUI.IntField(position, label, property.IntValue);
                }
                else if (propertyType == RuntimeSerializedPropertyType.Vector2Int)
                {
                    EditorGUI.BeginChangeCheck();
                    Vector2Int vector2IntValue = EditorGUI.Vector2IntField(position, label, property.Vector2IntValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.Vector2IntValue = vector2IntValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.Vector3Int)
                {
                    EditorGUI.BeginChangeCheck();
                    Vector3Int vector3IntValue = EditorGUI.Vector3IntField(position, label, property.Vector3IntValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.Vector3IntValue = vector3IntValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.RectInt)
                {
                    EditorGUI.BeginChangeCheck();
                    RectInt rectIntValue = EditorGUI.RectIntField(position, label, property.RectIntValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.RectIntValue = rectIntValue;
                    }
                }
                else if (propertyType == RuntimeSerializedPropertyType.BoundsInt)
                {
                    EditorGUI.BeginChangeCheck();
                    BoundsInt boundsIntValue = EditorGUI.BoundsIntField(position, label, property.BoundsIntValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        property.BoundsIntValue = boundsIntValue;
                    }
                }
                else
                {
                    int num = GUIUtility.GetControlID(s_GenericField, FocusType.Keyboard, position);
                    EditorGUI.PrefixLabel(position, num, label);
                }
            }
            // Handle Foldout
            else
            {
                Event tempEvent = new Event(Event.current);

                // Handle the actual foldout first, since that's the one that supports keyboard control.
                // This makes it work more consistent with PrefixLabel.
                childrenAreExpanded = property.IsExpanded;

                bool newChildrenAreExpanded = childrenAreExpanded;
                using (new EditorGUI.DisabledScope(!property.Editable))
                {
                    GUIStyle foldoutStyle = (DragAndDrop.activeControlID != -10) ? EditorStyles.foldout : EditorStyles.foldoutPreDrop;
                    newChildrenAreExpanded = EditorGUI.Foldout(position, childrenAreExpanded, s_PropertyFieldTempContent, true, foldoutStyle);
                }
                if (childrenAreExpanded && property.IsArray && property.ArraySize > property.RuntimeSerializedObject.SerializedObject.maxArraySizeForMultiEditing && property.RuntimeSerializedObject.SerializedObject.isEditingMultipleObjects)
                {
                    Rect boxRect = position;
                    boxRect.xMin += EditorGUIUtility.labelWidth - EasyGUI.Indent;

                    s_ArrayMultiInfoContent.text = s_ArrayMultiInfoContent.tooltip = string.Format(s_ArrayMultiInfoFormatString, property.RuntimeSerializedObject.SerializedObject.maxArraySizeForMultiEditing);
                    EditorGUI.LabelField(boxRect, GUIContent.none, s_ArrayMultiInfoContent, EditorStyles.helpBox);
                }

                if (newChildrenAreExpanded != childrenAreExpanded)
                {
                    // Recursive set expanded
                    if (Event.current.alt)
                    {
                        SetExpandedRecurse(property, newChildrenAreExpanded);
                    }
                    // Expand one element only
                    else
                    {
                        property.IsExpanded = newChildrenAreExpanded;
                    }
                }
                childrenAreExpanded = newChildrenAreExpanded;


                // Check for drag & drop events here, to add objects to an array by dragging to the foldout.
                // The event may have already been used by the Foldout control above, but we want to also use it here,
                // so we use the event copy we made prior to calling the Foldout method.

                // We need to use last s_LastControlID here to ensure we do not break duplicate functionality (fix for case 598389)
                // If we called GetControlID here s_LastControlID would be incremented and would not longer be in sync with GUIUtililty.keyboardFocus that
                // is used for duplicating (See DoPropertyFieldKeyboardHandling)
                int id = EditorGUIUtilityHelper.s_LastControlID;
                switch (tempEvent.type)
                {
                case EventType.DragExited:
                    if (GUI.enabled)
                    {
                        HandleUtility.Repaint();
                    }

                    break;

                case EventType.DragUpdated:
                case EventType.DragPerform:

                    if (position.Contains(tempEvent.mousePosition) && GUI.enabled)
                    {
                        Object[] references = DragAndDrop.objectReferences;

                        // Check each single object, so we can add multiple objects in a single drag.
                        Object[] oArray        = new Object[1];
                        bool     didAcceptDrag = false;
                        foreach (Object o in references)
                        {
                            oArray[0] = o;
                            Object validatedObject = ValidateObjectFieldAssignment(oArray, null, property, EasyGUI.ObjectFieldValidatorOptions.None);
                            if (validatedObject != null)
                            {
                                DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
                                if (tempEvent.type == EventType.DragPerform)
                                {
                                    property.AppendFoldoutPPtrValue(validatedObject);
                                    didAcceptDrag = true;
                                    DragAndDrop.activeControlID = 0;
                                }
                                else
                                {
                                    DragAndDrop.activeControlID = id;
                                }
                            }
                        }
                        if (didAcceptDrag)
                        {
                            GUI.changed = true;
                            DragAndDrop.AcceptDrag();
                        }
                    }
                    break;
                }
            }

            EndProperty();

            return(childrenAreExpanded);
        }
示例#3
0
 public override void OnGUI(Rect position, ReflectedProperty property, GUIContent label = null)
 {
     property.Value = EditorGUI.BoundsIntField(position, label, (BoundsInt)property.Value);
 }
示例#4
0
    public static void PropertyField(Rect position, SerializedProperty property, GUIContent label, bool includeChildren = false)
    {
        if (includeChildren || property.propertyType == SerializedPropertyType.Generic)
        {
            property.isExpanded = EditorGUILayout.Foldout(property.isExpanded, property.displayName);
            if (includeChildren && property.isExpanded)
            {
                foreach (SerializedProperty childProperty in property)
                {
                    PropertyField(position, childProperty, new GUIContent(property.displayName), false);
                }
            }

            return;
        }

        switch (property.propertyType)
        {
        case SerializedPropertyType.AnimationCurve:
            property.animationCurveValue = EditorGUI.CurveField(position, label, property.animationCurveValue);
            break;

        case SerializedPropertyType.ArraySize:
            property.intValue = EditorGUI.DelayedIntField(position, label, property.intValue);
            break;

        case SerializedPropertyType.Boolean:
            property.boolValue = EditorGUI.Toggle(position, label, property.boolValue);
            break;

        case SerializedPropertyType.Bounds:
            property.boundsValue = EditorGUI.BoundsField(position, label, property.boundsValue);
            break;

        case SerializedPropertyType.BoundsInt:
            property.boundsIntValue = EditorGUI.BoundsIntField(position, label, property.boundsIntValue);
            break;

        case SerializedPropertyType.Character:
            string newValue = EditorGUI.TextField(position, label, new string(new char[] { (char)property.intValue }));
            property.intValue = newValue.Length > 0 ? newValue[0] : '\0';
            break;

        case SerializedPropertyType.Color:
            property.colorValue = EditorGUI.ColorField(position, label, property.colorValue);
            break;

        case SerializedPropertyType.Enum:
            GUIContent[] displayNames = property.enumDisplayNames.Select(name => new GUIContent(name)).ToArray();
            property.enumValueIndex = EditorGUI.Popup(position, label, property.enumValueIndex, displayNames);
            break;

        case SerializedPropertyType.ExposedReference:
            property.exposedReferenceValue = EditorGUI.ObjectField(position, label, property.objectReferenceValue, ReflectionExtensions.GetType(property), true);
            break;

        case SerializedPropertyType.Float:
            property.floatValue = EditorGUI.FloatField(position, label, property.floatValue);
            break;

        case SerializedPropertyType.Integer:
            property.intValue = EditorGUI.IntField(position, label, property.intValue);
            break;

        case SerializedPropertyType.LayerMask:
            MethodInfo method = typeof(EditorGUI).GetMethods(BindingFlags.NonPublic | BindingFlags.Static).First(t => t.Name == "LayerMaskField");
            method.Invoke(null, new object[] { position, property, label });
            break;

        case SerializedPropertyType.ObjectReference:
            property.objectReferenceValue = EditorGUI.ObjectField(position, label, property.objectReferenceValue, ReflectionExtensions.GetType(property), true);
            break;

        case SerializedPropertyType.Quaternion:
            Quaternion quaternion       = property.quaternionValue;
            Vector4    quaternionValues = new Vector4(quaternion.x, quaternion.y, quaternion.z, quaternion.w);
            quaternionValues         = EditorGUI.Vector4Field(position, label, quaternionValues);
            property.quaternionValue = new Quaternion(quaternionValues.x, quaternionValues.y, quaternionValues.z, quaternionValues.w);
            break;

        case SerializedPropertyType.Rect:
            property.rectValue = EditorGUI.RectField(position, label, property.rectValue);
            break;

        case SerializedPropertyType.RectInt:
            property.rectIntValue = EditorGUI.RectIntField(position, label, property.rectIntValue);
            break;

        case SerializedPropertyType.String:
            property.stringValue = EditorGUI.TextField(position, label, property.stringValue);
            break;

        case SerializedPropertyType.Vector2:
            property.vector2Value = EditorGUI.Vector2Field(position, label, property.vector2Value);
            break;

        case SerializedPropertyType.Vector2Int:
            property.vector2IntValue = EditorGUI.Vector2IntField(position, label, property.vector2IntValue);
            break;

        case SerializedPropertyType.Vector3:
            property.vector3Value = EditorGUI.Vector3Field(position, label, property.vector3Value);
            break;

        case SerializedPropertyType.Vector3Int:
            property.vector3IntValue = EditorGUI.Vector3IntField(position, label, property.vector3IntValue);
            break;

        case SerializedPropertyType.Vector4:
            property.vector4Value = EditorGUI.Vector4Field(position, label, property.vector4Value);
            break;

        /*
         * case SerializedPropertyType.Gradient:
         * var method = typeof(EditorGUI).GetMethods(BindingFlags.NonPublic | BindingFlags.Static).First(t => t.Name == "GradientField");
         * var change = m.Invoke(null, new object[] { rect, gradient });
         * method = typeof(EditorGUI).GetMethods(BindingFlags.NonPublic | BindingFlags.Static).First(t => t.Name == "DefaultPropertyField");
         * method.Invoke(null, new object[] { position, property, label });
         * break;
         */
        default:
            Debug.LogError("SerializedPropertyType: " + property.propertyType + " not handled");
            break;
        }
    }
 public override void Draw(CutsceneEditor editor, CutscenePlayer player, Cutscene cutscene, Rect rect, int tokenIndex, GUIContent name, BoundsInt value, Type valueType, FieldInfo fieldInfo, Setter setter)
 {
     setter(EditorGUI.BoundsIntField(rect, name, value));
 }
 public static T FieldReturnDoNotSet <T>(this SerializedProperty property, GUIContent label, Rect area)
 {
     if (typeof(T) == typeof(float))
     {
         return((T)(object)EditorGUI.FloatField(area, label, property.floatValue));
     }
     if (typeof(T) == typeof(long))
     {
         return((T)(object)EditorGUI.LongField(area, label, property.longValue));
     }
     if (typeof(T) == typeof(uint))
     {
         return((T)(object)(uint)EditorGUI.LongField(area, label, property.longValue));
     }
     if (typeof(T) == typeof(int))
     {
         return((T)(object)EditorGUI.IntField(area, label, property.intValue));
     }
     if (typeof(T) == typeof(Vector2))
     {
         return((T)(object)EditorGUI.Vector2Field(area, label, property.vector2Value));
     }
     if (typeof(T) == typeof(Vector3))
     {
         return((T)(object)EditorGUI.Vector3Field(area, label, property.vector3Value));
     }
     if (typeof(T) == typeof(Vector2Int))
     {
         return((T)(object)EditorGUI.Vector2IntField(area, label, property.vector2IntValue));
     }
     if (typeof(T) == typeof(Vector3Int))
     {
         return((T)(object)EditorGUI.Vector3IntField(area, label, property.vector3IntValue));
     }
     if (typeof(T) == typeof(byte))
     {
         return((T)(object)(byte)EditorGUI.IntField(area, label, property.intValue));
     }
     if (typeof(T) == typeof(bool))
     {
         return((T)(object)EditorGUI.ToggleLeft(area, label, property.boolValue));
     }
     if (typeof(T) == typeof(string))
     {
         return((T)(object)EditorGUI.TextField(area, label, property.stringValue));
     }
     if (typeof(T) == typeof(Color))
     {
         return((T)(object)EditorGUI.ColorField(area, label, property.colorValue));
     }
     if (typeof(T) == typeof(AnimationCurve))
     {
         return((T)(object)EditorGUI.CurveField(area, label, property.animationCurveValue));
     }
     if (typeof(T) == typeof(Bounds))
     {
         return((T)(object)EditorGUI.BoundsField(area, label, property.boundsValue));
     }
     if (typeof(T) == typeof(BoundsInt))
     {
         return((T)(object)EditorGUI.BoundsIntField(area, label, property.boundsIntValue));
     }
     if (typeof(T) == typeof(double))
     {
         return((T)(object)EditorGUI.DoubleField(area, label, property.doubleValue));
     }
     if (typeof(T) == typeof(Vector4))
     {
         return((T)(object)EditorGUI.Vector4Field(area, label, property.vector4Value));
     }
     if (typeof(T) == typeof(Quaternion))
     {
         return((T)(object)Quaternion.Euler((Vector3)(object)EditorGUI.Vector3Field(area, label, (property.quaternionValue).eulerAngles)));
     }
     if (typeof(T) == typeof(Rect))
     {
         return((T)(object)EditorGUI.RectField(area, label, property.rectValue));
     }
     if (typeof(T) == typeof(RectInt))
     {
         return((T)(object)EditorGUI.RectIntField(area, label, property.rectIntValue));
     }
     if (typeof(T) == typeof(Object))
     {
         return((T)(object)EditorGUI.ObjectField(area, label, property.objectReferenceValue, typeof(T), true));
     }
     Debug.LogError($"Field not implemented for type {typeof( T )}");
     return(default(T));
 }
 public static T FieldOf <T>(this Rect area, GUIContent label, T value)
 {
     if (typeof(T) == typeof(float))
     {
         return((T)(object)EditorGUI.FloatField(area, label, (float)(object)value));
     }
     if (typeof(T) == typeof(long))
     {
         return((T)(object)EditorGUI.LongField(area, label, (long)(object)value));
     }
     if (typeof(T) == typeof(uint))
     {
         return((T)(object)(uint)EditorGUI.LongField(area, label, (uint)(object)value));
     }
     if (typeof(T) == typeof(int))
     {
         return((T)(object)EditorGUI.IntField(area, label, (int)(object)value));
     }
     if (typeof(T) == typeof(Vector2))
     {
         return((T)(object)EditorGUI.Vector2Field(area, label, (Vector2)(object)value));
     }
     if (typeof(T) == typeof(Vector3))
     {
         return((T)(object)EditorGUI.Vector3Field(area, label, (Vector3)(object)value));
     }
     if (typeof(T) == typeof(Vector2Int))
     {
         return((T)(object)EditorGUI.Vector2IntField(area, label, (Vector2Int)(object)value));
     }
     if (typeof(T) == typeof(Vector3Int))
     {
         return((T)(object)EditorGUI.Vector3IntField(area, label, (Vector3Int)(object)value));
     }
     if (typeof(T) == typeof(byte))
     {
         return((T)(object)(byte)EditorGUI.IntField(area, label, (byte)(object)value));
     }
     if (typeof(T) == typeof(bool))
     {
         return((T)(object)EditorGUI.ToggleLeft(area, label, (bool)(object)value));
     }
     if (typeof(T) == typeof(string))
     {
         return((T)(object)EditorGUI.TextField(area, label, (string)(object)value));
     }
     if (typeof(T) == typeof(Color))
     {
         return((T)(object)EditorGUI.ColorField(area, label, (Color)(object)value));
     }
     if (typeof(T) == typeof(AnimationCurve))
     {
         return((T)(object)EditorGUI.CurveField(area, label, (AnimationCurve)(object)value));
     }
     if (typeof(T) == typeof(Bounds))
     {
         return((T)(object)EditorGUI.BoundsField(area, label, (Bounds)(object)value));
     }
     if (typeof(T) == typeof(BoundsInt))
     {
         return((T)(object)EditorGUI.BoundsIntField(area, label, (BoundsInt)(object)value));
     }
     if (typeof(T) == typeof(double))
     {
         return((T)(object)EditorGUI.DoubleField(area, label, (double)(object)value));
     }
     if (typeof(T) == typeof(Vector4))
     {
         return((T)(object)EditorGUI.Vector4Field(area, label, (Vector4)(object)value));
     }
     if (typeof(T) == typeof(Quaternion))
     {
         return((T)(object)Quaternion.Euler((Vector3)(object)EditorGUI.Vector3Field(area, label, ((Quaternion)(object)value).eulerAngles)));
     }
     if (typeof(T) == typeof(Rect))
     {
         return((T)(object)EditorGUI.RectField(area, label, (Rect)(object)value));
     }
     if (typeof(T) == typeof(RectInt))
     {
         return((T)(object)EditorGUI.RectIntField(area, label, (RectInt)(object)value));
     }
     if (typeof(T) == typeof(Object))
     {
         return((T)(object)EditorGUI.ObjectField(area, label, (Object)(object)value, typeof(T), true));
     }
     Debug.LogError($"Field not implemented for type {typeof( T )}");
     return(default(T));
 }
示例#8
0
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        EditorGUI.PropertyField(position, property, label, true);

        if (property.objectReferenceValue == null)
        {
            return;
        }

        position.y     += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
        position.x     += 15f;
        position.width -= 15f;

        foldout = EditorGUI.Foldout(new Rect(position.x, position.y, position.width, EditorGUIUtility.singleLineHeight), foldout, "");

        EditorGUI.LabelField(position, "Preview");
        if (!foldout)
        {
            return;
        }
        position.y += EditorGUIUtility.singleLineHeight;

        System.Type type = property.objectReferenceValue.GetType();

        if (type == typeof(Sprite))
        {
            Texture texture = (property.objectReferenceValue as Sprite).texture;
            EditorGUI.LabelField(position, new GUIContent(texture));
            position.y += EditorGUIUtility.standardVerticalSpacing;
        }
        else if (type == typeof(Texture))
        {
            Texture texture = (property.objectReferenceValue as Texture);
            EditorGUI.LabelField(position, new GUIContent(texture));
            position.y += EditorGUIUtility.standardVerticalSpacing;
        }
        else if (type.IsSubclassOf(typeof(ScriptableObject)))
        {
            position.y += EditorGUIUtility.standardVerticalSpacing;
            EditorGUI.BeginDisabledGroup(true);
            position.height = EditorGUIUtility.singleLineHeight;

            var fields = type.GetFields();
            foreach (var field in fields)
            {
                Object obj   = property.objectReferenceValue;
                object value = field.GetValue(obj);

                System.Type baseType = (field.FieldType.BaseType != typeof(System.ValueType)) ? field.FieldType.BaseType : field.FieldType;

                switch (baseType.Name)
                {
                case "SByte":
                    EditorGUI.IntField(position, field.Name, (sbyte)value);
                    break;

                case "Char":
                    EditorGUI.TextField(position, field.Name, ((char)value).ToString());
                    break;

                case "Int16":
                    EditorGUI.IntField(position, field.Name, (short)value);
                    break;

                case "Int32":
                    EditorGUI.IntField(position, field.Name, (int)value);
                    break;

                case "Int64":
                    EditorGUI.LongField(position, field.Name, (long)value);
                    break;

                case "Byte":
                    EditorGUI.IntField(position, field.Name, (byte)value);
                    break;

                case "UInt16":
                    EditorGUI.IntField(position, field.Name, (ushort)value);
                    break;

                case "UInt32":
                    EditorGUI.LongField(position, field.Name, (uint)value);
                    break;

                case "float":
                    EditorGUI.FloatField(position, field.Name, (float)value);
                    break;

                case "Single":
                    EditorGUI.FloatField(position, field.Name, (float)((System.Single)value));
                    break;

                case "Boolean":
                    EditorGUI.Toggle(position, field.Name, (bool)value);
                    break;

                case "Enum":
                    EditorGUI.EnumFlagsField(position, field.Name, (System.Enum)value);
                    break;

                case "Vector2":
                    EditorGUI.Vector2Field(position, field.Name, (Vector2)value);
                    break;

                case "Vector2Int":
                    EditorGUI.Vector2IntField(position, field.Name, (Vector2Int)value);
                    break;

                case "Vector3":
                    EditorGUI.Vector3Field(position, field.Name, (Vector3)value);
                    break;

                case "Vector3Int":
                    EditorGUI.Vector3IntField(position, field.Name, (Vector3Int)value);
                    break;

                case "Vector4":
                    EditorGUI.Vector4Field(position, field.Name, (Vector4)value);
                    break;

                case "Rect":
                    EditorGUI.RectField(position, field.Name, (Rect)value);
                    break;

                case "RectInt":
                    EditorGUI.RectIntField(position, field.Name, (RectInt)value);
                    break;

                case "Bounds":
                    EditorGUI.BoundsField(position, field.Name, (Bounds)value);
                    break;

                case "BoundsInt":
                    EditorGUI.BoundsIntField(position, field.Name, (BoundsInt)value);
                    break;

                case "Color":
                    EditorGUI.ColorField(position, field.Name, (Color)value);
                    break;

                case "Gradient":
                    EditorGUI.GradientField(position, field.Name, (Gradient)value);
                    break;

                case "AnimationCurve":
                    EditorGUI.CurveField(position, field.Name, (AnimationCurve)value);
                    break;

                case "Object":
                    EditorGUI.ObjectField(position, field.Name, (Object)value, field.FieldType, true);
                    if (field.FieldType == typeof(Sprite))
                    {
                        position.y += EditorGUIUtility.singleLineHeight;
                        Texture texture = (value as Sprite).texture;
                        EditorGUI.LabelField(position, new GUIContent(texture));
                        position.y += EditorGUIUtility.standardVerticalSpacing;
                    }
                    else if (field.FieldType == typeof(Texture))
                    {
                        position.y += EditorGUIUtility.singleLineHeight;
                        Texture texture = (value as Texture);
                        EditorGUI.LabelField(position, new GUIContent(texture));
                        position.y += EditorGUIUtility.standardVerticalSpacing;
                    }
                    break;

                case "Range":
                    Range range = (Range)value;
                    RangeDrawer.Draw(position, range, new GUIContent(field.Name));
                    break;

                default:
                    EditorGUI.LabelField(position, field.Name);
                    position.x += EditorGUIUtility.labelWidth;
                    EditorGUI.HelpBox(position, "Cannot draw property field type: " + field.FieldType, MessageType.Error);
                    position.x -= EditorGUIUtility.labelWidth;
                    break;
                }
                position.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
            }
            EditorGUI.EndDisabledGroup();
        }
        else
        {
            position.y    += EditorGUIUtility.standardVerticalSpacing;
            position.yMax -= EditorGUIUtility.singleLineHeight * 1.5f;
            EditorGUI.HelpBox(position, "Use Preview only with type Sprite, Texture or ScriptableObject.", MessageType.Error);
        }
    }
示例#9
0
        private static VariableValue DrawIntBounds(Rect rect, VariableValue value)
        {
            var result = EditorGUI.BoundsIntField(rect, GUIContent.none, value.IntBounds);

            return(VariableValue.Create(result));
        }
 public override void Draw(Rect rect, GUIContent name, BoundsInt value, Type valueType, FieldInfo fieldInfo, Setter setter)
 {
     setter(EditorGUI.BoundsIntField(rect, name, value));
 }
示例#11
0
    private void InitVarsList()
    {
        reorderableList = new ReorderableList(serializedObject, pLuaInitialVars, true, true, true, true);

        reorderableList.elementHeight       = 66;
        reorderableList.drawElementCallback =
            (rect, index, isActive, isFocused) => {
            var ptargetElement = pLuaInitialVars.GetArrayElementAtIndex(index);
            if (ptargetElement != null)
            {
                var pName = ptargetElement.FindPropertyRelative("Name");
                var pType = ptargetElement.FindPropertyRelative("Type");

                rect.x     += 15;
                rect.height = 18;
                rect.width -= 30;

                var eType = (LuaVarObjectType)pType.enumValueIndex;
                SerializedProperty pVal = null;

                EditorGUI.PropertyField(rect, pName); rect.y += 20;
                EditorGUI.PropertyField(rect, pType); rect.y += 20;

                switch (eType)
                {
                case LuaVarObjectType.None:
                    break;

                case LuaVarObjectType.Vector2:
                    pVal = ptargetElement.FindPropertyRelative("vector2");
                    pVal.vector2Value = EditorGUI.Vector2Field(rect, "vector2", pVal.vector2Value);
                    break;

                case LuaVarObjectType.Vector2Int:
                    pVal = ptargetElement.FindPropertyRelative("vector2Int");
                    pVal.vector2IntValue = EditorGUI.Vector2IntField(rect, "vector2Int", pVal.vector2IntValue);
                    break;

                case LuaVarObjectType.Vector3:
                    pVal = ptargetElement.FindPropertyRelative("vector3");
                    pVal.vector3Value = EditorGUI.Vector3Field(rect, "vector3", pVal.vector3Value);
                    break;

                case LuaVarObjectType.Vector3Int:
                    pVal = ptargetElement.FindPropertyRelative("vector3Int");
                    pVal.vector3IntValue = EditorGUI.Vector3IntField(rect, "vector3Int", pVal.vector3IntValue);
                    break;

                case LuaVarObjectType.Vector4:
                    pVal = ptargetElement.FindPropertyRelative("vector4");
                    pVal.vector4Value = EditorGUI.Vector4Field(rect, "vector4", pVal.vector4Value);
                    break;

                case LuaVarObjectType.Rect:
                    pVal = ptargetElement.FindPropertyRelative("vector4");
                    pVal.vector4Value = EditorGUI.Vector4Field(rect, "vector4", pVal.vector4Value);
                    break;

                case LuaVarObjectType.RectInt:
                    pVal = ptargetElement.FindPropertyRelative("vector4");
                    pVal.vector4Value = EditorGUI.Vector4Field(rect, "vector4", pVal.vector4Value);
                    break;

                case LuaVarObjectType.Gradient:
                    pVal = ptargetElement.FindPropertyRelative("gradient");
                    EditorGUI.PropertyField(rect, pVal);
                    break;

                case LuaVarObjectType.Layer:
                    pVal          = ptargetElement.FindPropertyRelative("layer");
                    pVal.intValue = EditorGUI.LayerField(rect, "layer", pVal.intValue);
                    break;

                case LuaVarObjectType.Curve:
                    pVal = ptargetElement.FindPropertyRelative("curve");
                    pVal.animationCurveValue = EditorGUI.CurveField(rect, "curve", pVal.animationCurveValue);
                    break;

                case LuaVarObjectType.Color:
                    pVal            = ptargetElement.FindPropertyRelative("color");
                    pVal.colorValue = EditorGUI.ColorField(rect, "color", pVal.colorValue);
                    break;

                case LuaVarObjectType.BoundsInt:
                    pVal = ptargetElement.FindPropertyRelative("boundsInt");
                    pVal.boundsIntValue = EditorGUI.BoundsIntField(rect, "boundsInt", pVal.boundsIntValue);
                    break;

                case LuaVarObjectType.Bounds:
                    pVal             = ptargetElement.FindPropertyRelative("bounds");
                    pVal.boundsValue = EditorGUI.BoundsField(rect, "bounds", pVal.boundsValue);
                    break;

                case LuaVarObjectType.Object:
                    pVal = ptargetElement.FindPropertyRelative("objectVal");
                    EditorGUI.ObjectField(rect, pVal);
                    break;

                case LuaVarObjectType.GameObject:
                    pVal = ptargetElement.FindPropertyRelative("gameObjectVal");
                    EditorGUI.ObjectField(rect, pVal);
                    break;

                case LuaVarObjectType.Long:
                    pVal           = ptargetElement.FindPropertyRelative("longVal");
                    pVal.longValue = EditorGUI.LongField(rect, "longVal", pVal.longValue);
                    break;

                case LuaVarObjectType.Int:
                    pVal          = ptargetElement.FindPropertyRelative("intVal");
                    pVal.intValue = EditorGUI.IntField(rect, "intVal", pVal.intValue);
                    break;

                case LuaVarObjectType.String:
                    pVal             = ptargetElement.FindPropertyRelative("stringVal");
                    pVal.stringValue = EditorGUI.TextField(rect, "stringVal", pVal.stringValue);
                    break;

                case LuaVarObjectType.Double:
                    pVal             = ptargetElement.FindPropertyRelative("doubleVal");
                    pVal.doubleValue = EditorGUI.DoubleField(rect, "doubleVal", pVal.doubleValue);
                    break;

                case LuaVarObjectType.Bool:
                    pVal           = ptargetElement.FindPropertyRelative("boolVal");
                    pVal.boolValue = EditorGUI.Toggle(rect, "boolVal", pVal.boolValue);
                    break;
                }
                rect.y += 20;

                if (isFocused && EditorApplication.isPlaying)
                {
                    float w2 = rect.width / 2;
                    rect.width -= w2;
                    if (GUI.Button(rect, "UpdateVarFromLua"))
                    {
                        myScript.UpdateVarFromLua(myScript.LuaInitialVars[index]);
                    }
                    rect.x += w2;
                    if (GUI.Button(rect, "UpdateVarToLua"))
                    {
                        myScript.UpdateVarToLua(myScript.LuaInitialVars[index]);
                    }
                }
            }
        };

        reorderableList.drawElementBackgroundCallback = (rect, index, isActive, isFocused) => {
            if (styleHighlight == null)
            {
                styleHighlight = GUI.skin.FindStyle("MeTransitionSelectHead");
            }
            if (isFocused == false)
            {
                return;
            }
            rect.height = 66;
            GUI.Box(rect, GUIContent.none, styleHighlight);
        };
        reorderableList.drawHeaderCallback = (rect) => EditorGUI.LabelField(rect, pLuaInitialVars.displayName);
    }
        private void _drawValue(ref Rect rect, ValueS valueS)
        {
            rect.size = new Vector2(rect.width - (70 + 30 + 10 + 30) // subtract EditValue and Refresh and Remove Button
                                    , rect.height);

            //todo draw Value
            if (valueS.IsUnity)
            {
                var offset = new Vector2(15, 0);
                rect.position -= offset;         //subtract offset

                rect.size += new Vector2(70, 0); // no Edit Value Button
                Object obj;
                EditorGUI.BeginChangeCheck();
                {
                    obj = EditorGUI.ObjectField(rect, valueS.UValue, valueS.ValueType, false);
                }
                if (EditorGUI.EndChangeCheck())
                {
                    valueS.SetValue(obj);
                    Save();
                }
            }
            else
            {
                //todo non Unity Type

                var value = valueS.GetValue();

                if (value == null)
                {
                    valueS.SetValue(Activator.CreateInstance(valueS.ValueType));
                    Save();
                }

                _drawNonUnityValue <int>(ref rect, valueS, (pos, x) => EditorGUI.DelayedIntField(pos, (int)x.GetValue()));
                _drawNonUnityValue <float>(ref rect, valueS, (pos, x) => EditorGUI.DelayedFloatField(pos, (float)x.GetValue()));
                _drawNonUnityValue <double>(ref rect, valueS, (pos, x) => EditorGUI.DelayedDoubleField(pos, (double)x.GetValue()));
                _drawNonUnityValue <long>(ref rect, valueS, (pos, x) => EditorGUI.LongField(pos, (long)x.GetValue()));
                _drawNonUnityValue <string>(ref rect, valueS, (pos, x) => EditorGUI.DelayedTextField(pos, (string)x.GetValue()));
                _drawNonUnityValue <Vector2>(ref rect, valueS, (pos, x) => EditorGUI.Vector2Field(pos, "", (Vector2)x.GetValue()));
                _drawNonUnityValue <Vector2Int>(ref rect, valueS, (pos, x) => EditorGUI.Vector2IntField(pos, "", (Vector2Int)x.GetValue()));
                _drawNonUnityValue <Vector3>(ref rect, valueS, (pos, x) => EditorGUI.Vector3Field(pos, "", (Vector3)x.GetValue()));
                _drawNonUnityValue <Vector3Int>(ref rect, valueS, (pos, x) => EditorGUI.Vector3IntField(pos, "", (Vector3Int)x.GetValue()));
                _drawNonUnityValue <Vector4>(ref rect, valueS, (pos, x) => EditorGUI.Vector4Field(pos, "", (Vector4)x.GetValue()));
                _drawNonUnityValue <Color>(ref rect, valueS, (pos, x) => EditorGUI.ColorField(pos, (Color)x.GetValue()));
                _drawNonUnityValue <AnimationCurve>(ref rect, valueS, (pos, x) => EditorGUI.CurveField(pos, (AnimationCurve)x.GetValue()));
                _drawNonUnityValue <Bounds>(ref rect, valueS, (pos, x) => EditorGUI.BoundsField(pos, (Bounds)x.GetValue()));
                _drawNonUnityValue <BoundsInt>(ref rect, valueS, (pos, x) => EditorGUI.BoundsIntField(pos, (BoundsInt)x.GetValue()));
                _drawNonUnityValue <Rect>(ref rect, valueS, (pos, x) => EditorGUI.RectField(pos, (Rect)x.GetValue()));
                _drawNonUnityValue <RectInt>(ref rect, valueS, (pos, x) => EditorGUI.RectIntField(pos, (RectInt)x.GetValue()));
                _drawNonUnityValue <Enum>(ref rect, valueS, (pos, x) => EditorGUI.EnumFlagsField(pos, (Enum)x.GetValue()));
                _drawNonUnityValue <Gradient>(ref rect, valueS, (pos, x) => EditorGUI.GradientField(pos, (Gradient)x.GetValue()));

                rect.size = new Vector2(70, 26);

                if (GUI.Button(rect, "Edit Value"))
                {
                    _valueEditPopup.ValueS = valueS;

                    var pos = rect;
                    PopupWindow.Show(pos, _valueEditPopup);
                }
            }
            rect.position += new Vector2(rect.size.x + 10, 0);
        }
示例#13
0
        /// <summary>
        /// Makes the appropriate fields for the specified object type.
        /// </summary>
        /// <returns> Changed value of the object. </returns>
        public static object GenericObjectField(Rect position, object value)
        {
            object changedValue = null;

            switch (value)
            {
            case bool boolValue:
                changedValue = EditorGUI.Toggle(position, boolValue);
                break;

            case int intValue:
                changedValue = EditorGUI.IntField(position, intValue);
                break;

            case long longValue:
                changedValue = EditorGUI.LongField(position, longValue);
                break;

            case byte byteValue:
                changedValue = (byte)Mathf.Clamp(EditorGUI.IntField(position, byteValue), byte.MinValue, byte.MaxValue);
                break;

            case float floatValue:
                changedValue = EditorGUI.FloatField(position, floatValue);
                break;

            case double doubleValue:
                changedValue = EditorGUI.DoubleField(position, doubleValue);
                break;

            case string stringValue:
                changedValue = EditorGUI.TextField(position, stringValue);
                break;

            case Vector2 vector2Value:
                changedValue = EditorGUI.Vector2Field(position, GUIContent.none, vector2Value);
                break;

            case Vector3 vector3Value:
                changedValue = EditorGUI.Vector3Field(position, GUIContent.none, vector3Value);
                break;

            case Vector4 vector4Value:
                changedValue = EditorGUI.Vector4Field(position, GUIContent.none, vector4Value);
                break;

            case Vector2Int vector2IntValue:
                changedValue = EditorGUI.Vector2IntField(position, GUIContent.none, vector2IntValue);
                break;

            case Vector3Int vector3IntValue:
                changedValue = EditorGUI.Vector3IntField(position, GUIContent.none, vector3IntValue);
                break;

            case Quaternion quaternionValue:
                Vector3 vector3 = EditorGUI.Vector3Field(position, GUIContent.none, quaternionValue.eulerAngles);
                changedValue = Quaternion.Euler(vector3);
                break;

            case Rect rectValue:
                changedValue = EditorGUI.RectField(position, rectValue);
                break;

            case RectInt rectIntValue:
                changedValue = EditorGUI.RectIntField(position, rectIntValue);
                break;

            case Bounds boundsValue:
                changedValue = EditorGUI.BoundsField(position, boundsValue);
                break;

            case BoundsInt boundsIntValue:
                changedValue = EditorGUI.BoundsIntField(position, boundsIntValue);
                break;

            case Color colorValue:
                changedValue = EditorGUI.ColorField(position, colorValue);
                break;

            case Gradient gradientValue:
                changedValue = EditorGUI.GradientField(position, gradientValue);
                break;

            case Enum enumValue:
                if (Attribute.IsDefined(enumValue.GetType(), typeof(FlagsAttribute)))
                {
                    changedValue = EditorGUI.EnumFlagsField(position, enumValue);
                }
                else
                {
                    changedValue = EditorGUI.EnumPopup(position, enumValue);
                }
                break;

            case AnimationCurve animationCurveValue:
                changedValue = EditorGUI.CurveField(position, animationCurveValue);
                break;

            case LayerMask layerMaskValue:
                changedValue = (LayerMask)EditorGUI.MaskField(position, layerMaskValue, InternalEditorUtility.layers);
                break;
            }
            return(changedValue);
        }
示例#14
0
        // Draws the correct field for the parameter.
        private void DrawParameterField(ParameterInfo parameter)
        {
            Rect   position = _parameterRects[parameter.Position];
            Type   type     = parameter.ParameterType;
            string name     = ObjectNames.NicifyVariableName(parameter.Name);
            int    index    = parameter.Position;

            if (type == typeof(AnimationCurve))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.CurveField(position, name, (AnimationCurve)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(bool))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.Toggle(position, name, (bool)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(BoundsInt))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.BoundsIntField(position, name, (BoundsInt)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(Bounds))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.BoundsField(position, name, (Bounds)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(Color))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.ColorField(position, name, (Color)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(double))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.DoubleField(position, name, (double)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(float))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.FloatField(position, name, (float)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(int))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.IntField(position, name, (int)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(long))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.LongField(position, name, (long)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(Quaternion))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.Vector4Field(position, name, (Vector4)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(RectInt))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.RectIntField(position, name, (RectInt)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(Rect))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.RectField(position, name, (Rect)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(string))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.TextField(position, name, (string)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(Vector2Int))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.Vector2IntField(position, name, (Vector2Int)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(Vector2))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.Vector2Field(position, name, (Vector2)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(Vector3Int))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.Vector3IntField(position, name, (Vector3Int)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(Vector3))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.Vector3Field(position, name, (Vector3)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(Vector4))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.Vector4Field(position, name, (Vector4)_targetEventEntry.ParameterValues[index]);
            }
            else if (type.IsEnum)
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.EnumPopup(position, name, (Enum)_targetEventEntry.ParameterValues[index]);
            }
            else if (type == typeof(Object))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.ObjectField(position, name, (Object)_targetEventEntry.ParameterValues[index], type, true);
            }
            else if (type.BaseType == typeof(Component))
            {
                _targetEventEntry.ParameterValues[index] = EditorGUI.ObjectField(position, name, (Object)_targetEventEntry.ParameterValues[index], type, true);
            }
        }