示例#1
0
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        EditorGUIUtility.LookLikeControls();

        position.xMin += 4;
        position.xMax -= 4;

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

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

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

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

        case SerializedPropertyType.Bounds:
            EditorGUI.LabelField(position, label.text);
            position.y          += 20;
            property.boundsValue = EditorGUI.BoundsField(position, property.boundsValue);
            break;
        }
    }
示例#2
0
        private static void Initialize()
        {
            valueFieldActions = new Dictionary <Type, Func <Rect, GUIContent, object, object> >();

            valueFieldActions.Add(typeof(bool), (rect, label, obj) => EditorGUI.Toggle(rect, label, (bool)obj));
            valueFieldActions.Add(typeof(int), (rect, label, obj) => EditorGUI.IntField(rect, label, (int)obj));
            valueFieldActions.Add(typeof(long), (rect, label, obj) => EditorGUI.LongField(rect, label, (long)obj));
            valueFieldActions.Add(typeof(uint), (rect, label, obj) =>
            {
                var value = EditorGUI.LongField(rect, label, (uint)obj);
                if (value < 0)
                {
                    value = 0;
                }
                if (value > uint.MaxValue)
                {
                    value = uint.MaxValue;
                }
                return((uint)value);
            });
            valueFieldActions.Add(typeof(float), (rect, label, obj) => EditorGUI.FloatField(rect, label, (float)obj));
            valueFieldActions.Add(typeof(double), (rect, label, obj) => EditorGUI.DoubleField(rect, label, (double)obj));
            valueFieldActions.Add(typeof(string), (rect, label, obj) => EditorGUI.TextField(rect, label, (string)obj));
            valueFieldActions.Add(typeof(Vector2), (rect, label, obj) => EditorGUI.Vector2Field(rect, label, (Vector2)obj));
            valueFieldActions.Add(typeof(Vector3), (rect, label, obj) => EditorGUI.Vector3Field(rect, label, (Vector3)obj));
            valueFieldActions.Add(typeof(Vector4), (rect, label, obj) => EditorGUI.Vector4Field(rect, label, (Vector4)obj));
            valueFieldActions.Add(typeof(Vector2Int), (rect, label, obj) => EditorGUI.Vector2IntField(rect, label, (Vector2Int)obj));
            valueFieldActions.Add(typeof(Vector3Int), (rect, label, obj) => EditorGUI.Vector3IntField(rect, label, (Vector3Int)obj));
            valueFieldActions.Add(typeof(Color), (rect, label, obj) => EditorGUI.ColorField(rect, label, (Color)obj));
            valueFieldActions.Add(typeof(AnimationCurve), (rect, label, obj) => EditorGUI.CurveField(rect, label, (AnimationCurve)obj));
            valueFieldActions.Add(typeof(Bounds), (rect, label, obj) => EditorGUI.BoundsField(rect, label, (Bounds)obj));
            valueFieldActions.Add(typeof(Gradient), (rect, label, obj) => EditorGUI.GradientField(rect, label, (Gradient)obj));
            valueFieldActions.Add(typeof(Rect), (rect, label, obj) => EditorGUI.RectField(rect, label, (Rect)obj));
            // Add more when needed
        }
示例#3
0
 public override void OnGUI(Rect rect, string name, ref object value)
 {
     base.OnGUI(rect, name, ref value);
     EditorGUI.BeginDisabledGroup(IsReadOnly);
     EditorGUI.HandlePrefixLabel(rect, GetControlRect(), new GUIContent(name));
     value = EditorGUI.BoundsField(GetControlRect(32), (Bounds)value);
     EditorGUI.EndDisabledGroup();
 }
示例#4
0
    /*====================================*
    * Input Field
    *====================================*/
    public void BoundsField()
    {
        EditorGUI.BeginChangeCheck();
        Bounds bounds = EditorGUI.BoundsField(rect, guiContent.text, serializedProperty.boundsValue);

        if (EditorGUI.EndChangeCheck())
        {
            serializedProperty.boundsValue = bounds;
        }
    }
        public override void DoOnGUI(Rect position, SerializedProperty property, GUIContent label)
        {
            EditorGUI.BeginChangeCheck();
            switch (property.type)
            {
            case sVector4:
            case sVector4f:
            {
                float   vx      = GetProperty(property, "x").floatValue;
                float   vy      = GetProperty(property, "y").floatValue;
                float   vz      = GetProperty(property, "z").floatValue;
                float   vw      = GetProperty(property, "w").floatValue;
                Vector4 vector4 = EditorGUI.Vector4Field(position, label.text, new Vector4(vx, vy, vz, vw));
                if (EditorGUI.EndChangeCheck())
                {
                    GetProperty(property, "x").floatValue = vector4.x;
                    GetProperty(property, "y").floatValue = vector4.y;
                    GetProperty(property, "z").floatValue = vector4.z;
                    GetProperty(property, "w").floatValue = vector4.w;
                }
                break;
            }

            case sQuaternion:
            case sQuaternionf:
            {
                Quaternion quaternion = property.quaternionValue;
                Vector4    vector4    = EditorGUI.Vector4Field(position, label.text, new Vector4(quaternion.x, quaternion.y, quaternion.z, quaternion.w));
                if (EditorGUI.EndChangeCheck())
                {
                    property.quaternionValue = new Quaternion(vector4.x, vector4.y, vector4.z, vector4.w);
                }
                break;
            }

            case sBounds:
            case sAABB:
            {
                Bounds bounds = EditorGUI.BoundsField(position, label, property.boundsValue);
                if (EditorGUI.EndChangeCheck())
                {
                    property.boundsValue = bounds;
                }
                break;
            }

            default:
            {
                EditorGUI.LabelField(position, label.text, "Type not implemented");
                EditorGUI.EndChangeCheck();
                break;
            }
            }
        }
    private static object DrawProperty(Rect position, SerializedPropertyType propertyType, Type type, object value,
                                       GUIContent label)
    {
        switch (propertyType)
        {
        case SerializedPropertyType.Integer:
            return(EditorGUI.IntField(position, label, (int)value));

        case SerializedPropertyType.Boolean:
            return(EditorGUI.Toggle(position, label, (bool)value));

        case SerializedPropertyType.Float:
            return(EditorGUI.FloatField(position, label, (float)value));

        case SerializedPropertyType.String:
            return(EditorGUI.TextField(position, label, (string)value));

        case SerializedPropertyType.Color:
            return(EditorGUI.ColorField(position, label, (Color)value));

        case SerializedPropertyType.ObjectReference:
            return(EditorGUI.ObjectField(position, label, (UnityEngine.Object)value, type, true));

        case SerializedPropertyType.ExposedReference:
            return(EditorGUI.ObjectField(position, label, (UnityEngine.Object)value, type, true));

        case SerializedPropertyType.LayerMask:
            return(EditorGUI.LayerField(position, label, (int)value));

        case SerializedPropertyType.Enum:
            return(EditorGUI.EnumPopup(position, label, (Enum)value));

        case SerializedPropertyType.Vector2:
            return(EditorGUI.Vector2Field(position, label, (Vector2)value));

        case SerializedPropertyType.Vector3:
            return(EditorGUI.Vector3Field(position, label, (Vector3)value));

        case SerializedPropertyType.Vector4:
            return(EditorGUI.Vector4Field(position, label, (Vector4)value));

        case SerializedPropertyType.Rect:
            return(EditorGUI.RectField(position, label, (Rect)value));

        case SerializedPropertyType.AnimationCurve:
            return(EditorGUI.CurveField(position, label, (AnimationCurve)value));

        case SerializedPropertyType.Bounds:
            return(EditorGUI.BoundsField(position, label, (Bounds)value));

        default:
            throw new NotImplementedException("Unimplemented propertyType " + propertyType + ".");
        }
    }
示例#7
0
        protected override void OnControlGUI(Rect position)
        {
            EditorGUI.BeginChangeCheck();

            var newValue = EditorGUI.BoundsField(position, (Bounds)accessor.value);

            if (EditorGUI.EndChangeCheck())
            {
                accessor.RecordUndo();
                accessor.value = newValue;
            }
        }
示例#8
0
        protected override void OnGUI(Rect position, GUIContent label)
        {
            position = BeginBlock(metadata, position, label);

            var newValue = EditorGUI.BoundsField(position, (Bounds)metadata.value);

            if (EndBlock(metadata))
            {
                metadata.RecordUndo();
                metadata.value = newValue;
            }
        }
示例#9
0
        public override Bounds BoundsField(GUIContent content, Bounds value, Layout option)
        {
            var bounds = new ControlData(content, GUIStyles.None, option, ControlType.Bounds);

            Rect position;

            if (CanDrawControl(out position, bounds))
            {
                return(EditorGUI.BoundsField(position, content, value));
            }

            return(value);
        }
示例#10
0
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        Tooltip tooltipAttribute = attribute as Tooltip;

        if (property.propertyType == SerializedPropertyType.AnimationCurve)
        {
            property.animationCurveValue = EditorGUI.CurveField(position, new GUIContent(label.text, tooltipAttribute._tip), property.animationCurveValue);
        }

        if (property.propertyType == SerializedPropertyType.Boolean)
        {
            property.boolValue = EditorGUI.Toggle(position, new GUIContent(label.text, tooltipAttribute._tip), property.boolValue);
        }

        if (property.propertyType == SerializedPropertyType.Bounds)
        {
            property.boundsValue = EditorGUI.BoundsField(position, new GUIContent(label.text, tooltipAttribute._tip), property.boundsValue);
        }

        if (property.propertyType == SerializedPropertyType.Color)
        {
            property.colorValue = EditorGUI.ColorField(position, new GUIContent(label.text, tooltipAttribute._tip),
                                                       property.colorValue);
        }

        if (property.propertyType == SerializedPropertyType.Float)
        {
            property.floatValue = EditorGUI.FloatField(position,
                                                       new GUIContent(label.text, tooltipAttribute._tip), property.floatValue);
        }

        if (property.propertyType == SerializedPropertyType.Integer)
        {
            property.intValue = EditorGUI.IntField(position, new GUIContent(label.text, tooltipAttribute._tip), property.intValue);
        }

        if (property.propertyType == SerializedPropertyType.Rect)
        {
            property.rectValue = EditorGUI.RectField(position, new GUIContent(label.text, tooltipAttribute._tip),
                                                     property.rectValue);
        }

        if (property.propertyType == SerializedPropertyType.String)
        {
            property.stringValue = EditorGUI.TextField(position,
                                                       new GUIContent(label.text, tooltipAttribute._tip), property.stringValue);
        }
    }
示例#11
0
        //<summary> в этом методе мы рисуем и отображаем поля свойствы класса </summary>
        private object DoFiled(Type type, object value, Rect position, ref float size)
        {
            object result = null;

            switch (type.Name)
            {
            case "Int32": result = EditorGUI.IntField(position, (int)value); size = 22; break;

            case "Single": result = EditorGUI.FloatField(position, (float)value); size = 22; break;

            case "Double": result = EditorGUI.DoubleField(position, (double)value); size = 22; break;

            case "Boolean": result = EditorGUI.Toggle(position, (bool)value); size = 22; break;

            case "String": result = EditorGUI.TextField(position, (string)value); size = 22; break;

            case "Vector2": result = EditorGUI.Vector2Field(position, GUIContent.none, (Vector2)value); size = 22; break;

            case "Rect": result = EditorGUI.RectField(position, (Rect)value); size = 42; break;

            case "Bounds": result = EditorGUI.BoundsField(position, (Bounds)value); size = 42; break;
            }

            if (result == null)
            {
                size = 22;

                if (type.IsEnum)
                {
                    result = EditorGUI.EnumPopup(position, (Enum)(object)value);
                }

                if (type.IsArray)
                {
                    EditorGUI.LabelField(position, "Data array is not displayed");
                }

                if (typeof(IList).IsAssignableFrom(type) && type.Name == "List`1")
                {
                    IList list = value as IList;
                    result = EditorGUI.IntField(position, list.Count);
                }
            }

            return(result);
        }
        void OnGUI()
        {
            EditorGUI.BeginChangeCheck();
            _bound = EditorGUI.BoundsField(new Rect(5, 5, 200, 34), _bound);
            if (EditorGUI.EndChangeCheck())
            {
                ShowNotification(new GUIContent("Something changed."));
            }

            _color = EditorGUI.ColorField(new Rect(5, 44, 200, 17), _color);

            EditorGUI.BeginChangeCheck();
            _int = EditorGUI.IntSlider(new Rect(5, 66, 200, 17), _int, -5, 5);
            if (EditorGUI.EndChangeCheck())
            {
                ShowNotification(new GUIContent("Something changed."));
            }
        }
示例#13
0
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        EditorGUI.BeginProperty(position, label, property);

        var minx = property.FindPropertyRelative("minimum").FindPropertyRelative("x").intValue;
        var miny = property.FindPropertyRelative("minimum").FindPropertyRelative("y").intValue;
        var minz = property.FindPropertyRelative("minimum").FindPropertyRelative("z").intValue;

        var maxx = property.FindPropertyRelative("maximum").FindPropertyRelative("x").intValue;
        var maxy = property.FindPropertyRelative("maximum").FindPropertyRelative("y").intValue;
        var maxz = property.FindPropertyRelative("maximum").FindPropertyRelative("z").intValue;

        var center = new Vector3((minx + maxx) / 2.0f, (miny + maxy) / 2.0f, (minz + maxz) / 2.0f);
        var size   = new Vector3(maxx - minx, maxy - miny, maxz - minz);
        var bounds = new Bounds(center, size);

        EditorGUI.BoundsField(position, label, bounds);

        EditorGUI.EndProperty();
    }
    protected void DrawCondition(Rect pos, AmountCondition condition, GUIContent label)
    {
        InLine.SetRect(pos, 0, 0, 6);
        {
            condition.typeOfFind = (FindType)EditorGUI.EnumPopup(InLine.NextRect(), condition.typeOfFind);
            switch (condition.typeOfFind)
            {
            case FindType.Tag:
                condition.checkTag = EditorGUI.TagField(InLine.NextRect(), condition.checkTag);
                break;

            case FindType.Layer:
                condition.layer = EditorGUI.MaskField(InLine.NextRect(), condition.layer, FindLayerNames());
                break;

            case FindType.ByType:
                condition.typeTemplate = EditorGUI.ObjectField(InLine.NextRect(), condition.typeTemplate, typeof(UnityEngine.Object), true);
                if (condition.typeTemplate == null)
                {
                    EditorGUILayout.HelpBox("A Amount Condition needs a type template", MessageType.Warning);
                }
                break;
            }
            EditorGUI.LabelField(InLine.GetLine(0, pos.width / 3, 5f), "Current", GUIStyle.none);
            EditorGUI.IntField(InLine.NextRect(), condition.numOfObjects, GUIStyle.none);
        }

        InLine.SetRect(pos, 1, 0, 6);
        {
            EditorGUI.LabelField(InLine.NextRect(), "Remaining");
            condition.typeOfCompare = (CompareType)EditorGUI.EnumPopup(InLine.NextRect(), condition.typeOfCompare);
            condition.amount        = EditorGUI.IntField(InLine.NextRect(), condition.amount);
        }

        condition.triggerArea = EditorGUI.BoundsField(InLine.GetLine(0, pos.width / 2, 1), condition.triggerArea);

        InLine.Reset();
    }
    protected void DrawCondition(Rect pos, AreaCondition condition, GUIContent label)
    {
        InLine.SetRect(pos, 0, 0, 6);
        {
            EditorGUI.LabelField(InLine.NextRect(), "Area");
        }
        condition.triggerArea = EditorGUI.BoundsField(InLine.GetLine(0, pos.width / 2, 1), condition.triggerArea);

        InLine.SetRect(pos, 0, 50, 6);
        {
            EditorGUI.LabelField(InLine.NextRect(), "UsePlayer");
            condition.UsePlayer = EditorGUI.Toggle(InLine.NextRect(true), condition.UsePlayer);
        }
        if (!condition.UsePlayer)
        {
            condition.checkObject = (GameObject)EditorGUI.ObjectField(InLine.GetLine(1, 0, 2), condition.checkObject, typeof(GameObject), true);
            if (!condition.checkObject)
            {
                EditorGUILayout.HelpBox("CheckObject is null for AreaCondition", MessageType.Warning);
            }
        }
        InLine.Reset();
    }
示例#16
0
 public override void OnGUI(Rect position, ReflectedProperty property, GUIContent label = null)
 {
     property.Value = EditorGUI.BoundsField(position, label, (Bounds)property.Value);
 }
示例#17
0
 /// <summary>
 ///
 /// </summary>
 /// <returns></returns>
 protected override Bounds DrawAndUpdateValue()
 {
     return(EditorGUI.BoundsField(ScreenRect, new GUIContent(Label), m_cachedValue));
 }
示例#18
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);
        }
示例#19
0
 public override void Draw(CutsceneEditor editor, CutscenePlayer player, Cutscene cutscene, Rect rect, int tokenIndex, GUIContent name, Bounds value, Type valueType, FieldInfo fieldInfo, Setter setter)
 {
     setter(EditorGUI.BoundsField(rect, name, value));
 }
示例#20
0
        public static object ValueField(Rect rect, object value, Type type)
        {
            object     newValue     = value;
            GUIContent labelContent = GUIContent.none;
            var        typeCode     = SerializableValue.TypeToSerializableTypeCode(type);

            switch (typeCode)
            {
            case SerializableTypeCode.String:
            {
                string str = value as string;
                str      = str ?? "";
                newValue = EditorGUI.DelayedTextField(rect, str);
            }
            break;

            case SerializableTypeCode.Int32:
            {
                int n = (int)value;
                newValue = EditorGUI.DelayedIntField(rect, n);
            }
            break;

            case SerializableTypeCode.Single:
            {
                float f = (float)value;
                newValue = EditorGUI.DelayedFloatField(rect, f);
            }
            break;

            case SerializableTypeCode.Boolean:
            {
                bool b;
                b        = (bool)value;
                newValue = EditorGUI.Toggle(rect, b);
            }
            break;

            case SerializableTypeCode.UnityObject:
            {
                UnityEngine.Object obj = value as UnityEngine.Object;
                newValue = EditorGUI.ObjectField(rect, obj, type, true);
            }
            break;

            case SerializableTypeCode.Vector2:
            {
                Vector2 v = (Vector2)value;
                newValue = EditorGUI.Vector2Field(rect, labelContent, v);
            }
            break;

            case SerializableTypeCode.Vector3:
            {
                Vector3 v = (Vector3)value;
                newValue = EditorGUI.Vector3Field(rect, labelContent, v);
            }
            break;

            case SerializableTypeCode.Vector4:
            {
                Vector4 v = (Vector4)value;
                newValue = EditorGUI.Vector4Field(rect, labelContent, v);
            }
            break;

            case SerializableTypeCode.Color:
            {
                Color v = (Color)value;
                newValue = EditorGUI.ColorField(rect, labelContent, v);
            }
            break;

            case SerializableTypeCode.Rect:
            {
                Rect v = (Rect)value;
                newValue = EditorGUI.RectField(rect, labelContent, v);
            }
            break;

            case SerializableTypeCode.Bounds:
            {
                Bounds v = (Bounds)value;
                newValue = EditorGUI.BoundsField(rect, labelContent, v);
            }
            break;

            case SerializableTypeCode.AnimationCurve:
            {
                AnimationCurve v = (AnimationCurve)value;
                newValue = EditorGUI.CurveField(rect, labelContent, v);
            }
            break;
            }
            return(newValue);
        }
        protected void OnGUIOfPropertyType(SerializedPropertyType type, Rect rect, GUIContent label)
        {
            switch (type)
            {
            case SerializedPropertyType.AnimationCurve:
                EditorGUI.BeginChangeCheck(); GetAnimationCurve();
                animationCurveValue = EditorGUI.CurveField(rect, label, animationCurveValue);
                if (EditorGUI.EndChangeCheck())
                {
                    SetAnimationCurve();
                }
                return;

            case SerializedPropertyType.Boolean:
                EditorGUI.BeginChangeCheck(); GetBool();
                boolValue = EditorGUI.Toggle(rect, label, boolValue);
                if (EditorGUI.EndChangeCheck())
                {
                    SetBool();
                }
                return;

            case SerializedPropertyType.Bounds:
                EditorGUI.BeginChangeCheck(); GetBounds();
                boundsValue = EditorGUI.BoundsField(rect, label, boundsValue);
                if (EditorGUI.EndChangeCheck())
                {
                    SetBounds();
                }
                return;

            case SerializedPropertyType.Color:
                EditorGUI.BeginChangeCheck(); GetColor();
                colorValue = EditorGUI.ColorField(rect, label, colorValue);
                if (EditorGUI.EndChangeCheck())
                {
                    SetColor();
                }
                return;

            case SerializedPropertyType.Enum:
                EditorGUI.BeginChangeCheck(); GetEnum();
                enumValue = EditorGUI.EnumPopup(rect, label, enumValue);
                if (EditorGUI.EndChangeCheck())
                {
                    SetEnum();
                }
                return;

            case SerializedPropertyType.Float:
                EditorGUI.BeginChangeCheck(); GetFloat();
                floatValue = EditorGUI.FloatField(rect, label, floatValue);
                if (EditorGUI.EndChangeCheck())
                {
                    SetFloat();
                }
                return;

            case SerializedPropertyType.Integer:
                EditorGUI.BeginChangeCheck(); GetInt();
                intValue = EditorGUI.IntField(rect, label, intValue);
                if (EditorGUI.EndChangeCheck())
                {
                    SetInt();
                }
                return;

            case SerializedPropertyType.LayerMask:
                SerializedProperty property = BasePropertyDrawer.property;
                GetLayerMask();
                EditorKit.LayerMaskField(rect, label, layerMaskValue,
                                         mask =>
                {
                    property.serializedObject.Update();
                    BasePropertyDrawer.property = property;
                    layerMaskValue = mask;
                    SetLayerMask();
                    property.serializedObject.ApplyModifiedProperties();
                });
                return;

            case SerializedPropertyType.ObjectReference:
                EditorGUI.BeginChangeCheck(); GetObjectReference();
                objectReferenceValue = EditorGUI.ObjectField(rect, label, objectReferenceValue,
                                                             fieldInfo.FieldType, !EditorUtility.IsPersistent(BasePropertyDrawer.property.serializedObject.targetObject));
                if (EditorGUI.EndChangeCheck())
                {
                    SetObjectReference();
                }
                return;

            case SerializedPropertyType.Rect:
                EditorGUI.BeginChangeCheck(); GetRect();
                rectValue = EditorGUI.RectField(rect, label, rectValue);
                if (EditorGUI.EndChangeCheck())
                {
                    SetRect();
                }
                return;

            case SerializedPropertyType.String:
                EditorGUI.BeginChangeCheck(); GetString();
                stringValue = EditorGUI.TextField(rect, label, stringValue);
                if (EditorGUI.EndChangeCheck())
                {
                    SetString();
                }
                return;

            case SerializedPropertyType.Vector2:
                EditorGUI.BeginChangeCheck(); GetVector2();
                vector2Value = EditorGUI.Vector2Field(rect, label, vector2Value);
                if (EditorGUI.EndChangeCheck())
                {
                    SetVector2();
                }
                return;

            case SerializedPropertyType.Vector3:
                EditorGUI.BeginChangeCheck(); GetVector3();
                vector3Value = EditorGUI.Vector3Field(rect, label, vector3Value);
                if (EditorGUI.EndChangeCheck())
                {
                    SetVector3();
                }
                return;

            case SerializedPropertyType.Vector4:
                EditorGUI.BeginChangeCheck(); GetVector4();
                vector4Value = EditorGUI.Vector4Field(rect, label.text, vector4Value);
                if (EditorGUI.EndChangeCheck())
                {
                    SetVector4();
                }
                return;

            default:
                EditorGUI.LabelField(rect, label.text, "Not supported");
                return;
            }
        }
示例#22
0
        protected void DrawProperty(Rect pos, SerializedProperty prop, bool title)
        {
            GUIContent label = GUIContent.none;

            if (title)
            {
                label = new GUIContent(prop.displayName);
            }
            if (prop.propertyType == SerializedPropertyType.AnimationCurve)
            {
                prop.animationCurveValue = EditorGUI.CurveField(pos, label, prop.animationCurveValue);
            }
            else if (prop.propertyType == SerializedPropertyType.ArraySize)
            {
            }
            else if (prop.propertyType == SerializedPropertyType.Boolean)
            {
                prop.boolValue = EditorGUI.Toggle(pos, label, prop.boolValue);
            }
            else if (prop.propertyType == SerializedPropertyType.Bounds)
            {
                prop.boundsValue = EditorGUI.BoundsField(pos, label, prop.boundsValue);
            }
            else if (prop.propertyType == SerializedPropertyType.Character)
            {
                prop.intValue = EditorGUI.IntField(pos, label, prop.intValue);
            }
            else if (prop.propertyType == SerializedPropertyType.Color)
            {
                prop.colorValue = EditorGUI.ColorField(pos, label, prop.colorValue);
            }
            else if (prop.propertyType == SerializedPropertyType.Enum)
            {
                string[]     optionNames = prop.enumNames;
                GUIContent[] options     = new GUIContent[optionNames.Length];
                for (int i = 0; i < optionNames.Length; i++)
                {
                    options[i] = new GUIContent(optionNames[i]);
                }
                prop.enumValueIndex = EditorGUI.Popup(pos, label, prop.intValue, options);
            }
            else if (prop.propertyType == SerializedPropertyType.Float)
            {
                prop.floatValue = EditorGUI.FloatField(pos, label, prop.floatValue);
                //      } else if (prop.propertyType == SerializedPropertyType.Generic) {
                //          DrawGeneric(prop, pos);
            }
            else if (prop.propertyType == SerializedPropertyType.Gradient)
            {
            }
            else if (prop.propertyType == SerializedPropertyType.Integer)
            {
                prop.intValue = EditorGUI.IntField(pos, label, prop.intValue);
            }
            else if (prop.propertyType == SerializedPropertyType.LayerMask)
            {
                prop.intValue = EditorGUI.LayerField(pos, label, prop.intValue);
            }
            else if (prop.propertyType == SerializedPropertyType.ObjectReference)
            {
                prop.objectReferenceValue = EditorGUI.ObjectField(pos, label, prop.objectReferenceValue, Type.GetType(prop.type), true);
            }
            else if (prop.propertyType == SerializedPropertyType.Rect)
            {
                prop.rectValue = EditorGUI.RectField(pos, label, prop.rectValue);
            }
            else if (prop.propertyType == SerializedPropertyType.String)
            {
                prop.stringValue = EditorGUI.TextField(pos, label, prop.stringValue);
            }
            else if (prop.propertyType == SerializedPropertyType.Vector2)
            {
                prop.vector2Value = EditorGUI.Vector2Field(pos, label.text, prop.vector2Value);
            }
            else if (prop.propertyType == SerializedPropertyType.Vector3)
            {
                prop.vector3Value = EditorGUI.Vector2Field(pos, label.text, prop.vector3Value);
            }
            else if (prop.propertyType == SerializedPropertyType.Generic)
            {
                if (prop.type == typeof(Quaternion).ToString())
                {
                    DrawVec4(prop, label, pos);
                }
            }
        }
        public static object DefaultPropertyField(Rect position, GUIContent label, object value, System.Type valueType)
        {
            var propertyType = (valueType != null) ? EditorHelper.GetPropertyType(valueType) : SerializedPropertyType.Generic;

            switch (propertyType)
            {
            case SerializedPropertyType.Integer:
                EditorGUI.BeginChangeCheck();
                int num1 = EditorGUI.IntField(position, label, ConvertUtil.ToInt(value));
                if (EditorGUI.EndChangeCheck())
                {
                    return(num1);
                }
                else
                {
                    break;
                }

            case SerializedPropertyType.Boolean:
                EditorGUI.BeginChangeCheck();
                bool flag2 = EditorGUI.Toggle(position, label, ConvertUtil.ToBool(value));
                if (EditorGUI.EndChangeCheck())
                {
                    return(flag2);
                }
                else
                {
                    break;
                }

            case SerializedPropertyType.Float:
                EditorGUI.BeginChangeCheck();
                float num2 = EditorGUI.FloatField(position, label, ConvertUtil.ToSingle(value));
                if (EditorGUI.EndChangeCheck())
                {
                    return(num2);
                }
                else
                {
                    break;
                }

            case SerializedPropertyType.String:
                EditorGUI.BeginChangeCheck();
                string str1 = EditorGUI.TextField(position, label, ConvertUtil.ToString(value));
                if (EditorGUI.EndChangeCheck())
                {
                    return(str1);
                }
                else
                {
                    break;
                }

            case SerializedPropertyType.Color:
                EditorGUI.BeginChangeCheck();
                Color color = EditorGUI.ColorField(position, label, ConvertUtil.ToColor(value));
                if (EditorGUI.EndChangeCheck())
                {
                    return(color);
                }
                else
                {
                    break;
                }

            case SerializedPropertyType.ObjectReference:
                EditorGUI.BeginChangeCheck();
                object obj = EditorGUI.ObjectField(position, label, value as UnityEngine.Object, valueType, true);
                if (EditorGUI.EndChangeCheck())
                {
                    return(obj);
                }
                break;

            case SerializedPropertyType.LayerMask:
                EditorGUI.BeginChangeCheck();
                LayerMask mask = (value is LayerMask) ? (LayerMask)value : (LayerMask)ConvertUtil.ToInt(value);
                mask = SPEditorGUI.LayerMaskField(position, label, mask);
                if (EditorGUI.EndChangeCheck())
                {
                    return(mask);
                }
                break;

            case SerializedPropertyType.Enum:
                if (valueType.GetCustomAttributes(typeof(System.FlagsAttribute), false).Any())
                {
                    EditorGUI.BeginChangeCheck();
                    var e = SPEditorGUI.EnumFlagField(position, label, ConvertUtil.ToEnumOfType(valueType, value));
                    if (EditorGUI.EndChangeCheck())
                    {
                        return(e);
                    }
                }
                else
                {
                    EditorGUI.BeginChangeCheck();
                    var e = SPEditorGUI.EnumPopupExcluding(position, label, ConvertUtil.ToEnumOfType(valueType, value));
                    if (EditorGUI.EndChangeCheck())
                    {
                        return(e);
                    }
                }
                break;

            case SerializedPropertyType.Vector2:
                EditorGUI.BeginChangeCheck();
                var v2 = EditorGUI.Vector2Field(position, label, ConvertUtil.ToVector2(value));
                if (EditorGUI.EndChangeCheck())
                {
                    return(v2);
                }
                break;

            case SerializedPropertyType.Vector3:
                EditorGUI.BeginChangeCheck();
                var v3 = EditorGUI.Vector3Field(position, label, ConvertUtil.ToVector3(value));
                if (EditorGUI.EndChangeCheck())
                {
                    return(v3);
                }
                break;

            case SerializedPropertyType.Vector4:
                EditorGUI.BeginChangeCheck();
                var v4 = EditorGUI.Vector4Field(position, label.text, ConvertUtil.ToVector4(value));
                if (EditorGUI.EndChangeCheck())
                {
                    return(v4);
                }
                break;

            case SerializedPropertyType.Rect:
                EditorGUI.BeginChangeCheck();
                Rect rect = (value is Rect) ? (Rect)value : new Rect();
                rect = EditorGUI.RectField(position, label, rect);
                if (EditorGUI.EndChangeCheck())
                {
                    return(rect);
                }
                break;

            case SerializedPropertyType.ArraySize:
                EditorGUI.BeginChangeCheck();
                int num3 = EditorGUI.IntField(position, label, ConvertUtil.ToInt(value), EditorStyles.numberField);
                if (EditorGUI.EndChangeCheck())
                {
                    return(num3);
                }
                break;

            case SerializedPropertyType.Character:
                bool changed = GUI.changed;
                GUI.changed = false;
                string str2 = EditorGUI.TextField(position, label, new string(ConvertUtil.ToChar(value), 1));
                if (GUI.changed)
                {
                    if (str2.Length == 1)
                    {
                        return(str2[0]);
                    }
                    else
                    {
                        GUI.changed = false;
                    }
                }
                GUI.changed = GUI.changed | changed;
                break;

            case SerializedPropertyType.AnimationCurve:
                EditorGUI.BeginChangeCheck();
                AnimationCurve curve = value as AnimationCurve;
                curve = EditorGUI.CurveField(position, label, curve);
                if (EditorGUI.EndChangeCheck())
                {
                    return(curve);
                }
                break;

            case SerializedPropertyType.Bounds:
                EditorGUI.BeginChangeCheck();
                Bounds bnds = (value is Bounds) ? (Bounds)value : new Bounds();
                bnds = EditorGUI.BoundsField(position, label, bnds);
                if (EditorGUI.EndChangeCheck())
                {
                    return(bnds);
                }
                break;

            case SerializedPropertyType.Gradient:
                EditorGUI.BeginChangeCheck();
                Gradient grad = value as Gradient;
                grad = SPEditorGUI.GradientField(position, label, grad);
                if (EditorGUI.EndChangeCheck())
                {
                    return(grad);
                }
                break;

            default:
                EditorGUI.PrefixLabel(position, label);
                break;
            }

            return(value);
        }
        // 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);
        }
示例#25
0
    public override void OnGUI(Rect pRect, SerializedProperty pProperty, GUIContent pLabel)
    {
#if UNITY_EDITOR
        GUI.enabled = false;
        switch (pProperty.propertyType)
        {
        case SerializedPropertyType.Integer:
            EditorGUI.LabelField(pRect, pLabel.text, pProperty.intValue.ToString());
            break;

        case SerializedPropertyType.Boolean:
            EditorGUI.LabelField(pRect, pLabel.text, pProperty.boolValue.ToString());
            break;

        case SerializedPropertyType.Float:
            EditorGUI.LabelField(pRect, pLabel.text, pProperty.floatValue.ToString("0.00000"));
            break;

        case SerializedPropertyType.String:
        case SerializedPropertyType.Character:
            EditorGUI.LabelField(pRect, pLabel.text, pProperty.stringValue);
            break;

        case SerializedPropertyType.Color:
            EditorGUI.ColorField(pRect, pLabel.text, pProperty.colorValue);
            break;

        case SerializedPropertyType.ObjectReference:
            EditorGUI.ObjectField(pRect, pLabel.text, pProperty.objectReferenceValue, typeof(System.Object), true);
            break;

        case SerializedPropertyType.Vector2:
            EditorGUI.Vector2Field(pRect, pLabel.text, pProperty.vector2Value);
            break;

        case SerializedPropertyType.Vector3:
            EditorGUI.Vector3Field(pRect, pLabel.text, pProperty.vector3Value);
            break;

        case SerializedPropertyType.Vector4:
            EditorGUI.Vector4Field(pRect, pLabel.text, pProperty.vector4Value);
            break;

        case SerializedPropertyType.Quaternion:
            EditorGUI.LabelField(pRect, pLabel.text, pProperty.quaternionValue.ToString());
            break;

        case SerializedPropertyType.Rect:
            EditorGUI.RectField(pRect, pLabel.text, pProperty.rectValue);
            break;

        case SerializedPropertyType.ArraySize:
            EditorGUI.LabelField(pRect, pLabel.text, pProperty.arraySize.ToString());
            break;

        case SerializedPropertyType.AnimationCurve:
            EditorGUI.CurveField(pRect, pLabel.text, pProperty.animationCurveValue);
            break;

        case SerializedPropertyType.Bounds:
            EditorGUI.BoundsField(pRect, pProperty.boundsValue);
            break;

        case SerializedPropertyType.Gradient:
        default:
            EditorGUI.LabelField(pRect, pLabel.text, "(not supported)");
            break;
        }
        GUI.enabled = true;
#endif
    }
示例#26
0
        void DrawDirectField(bool readOnly, Rect?rect)
        {
            object value = rawValue;

            GUI.changed = false;
            try {
                switch (currentType)
                {
                case PropertyType.Bool:
                    if (rect.HasValue)
                    {
                        value = EditorGUI.Toggle(rect.Value, nameContent, (bool)(value ?? false));
                    }
                    else
                    {
                        value = EditorGUILayout.Toggle(nameContent, (bool)(value ?? false));
                    }
                    break;

                case PropertyType.Enum:
                    if (masked)
                    {
                        if (rect.HasValue)
                        {
                            value = Helper.MaskedEnumField(rect.Value, nameContent, requiredType, value);
                        }
                        else
                        {
                            value = Helper.MaskedEnumField(nameContent, requiredType, value);
                        }
                        break;
                    }
                    if (rect.HasValue)
                    {
                        value = Helper.EnumField(rect.Value, nameContent, requiredType, value);
                    }
                    else
                    {
                        value = Helper.EnumField(nameContent, requiredType, value);
                    }
                    break;

                case PropertyType.Long:
#if UNITY_5
                    if (rect.HasValue)
                    {
                        value = EditorGUI.LongField(rect.Value, nameContent, (long)(value ?? 0L));
                    }
                    else
                    {
                        value = EditorGUILayout.LongField(nameContent, (long)(value ?? 0L));
                    }
                    break;
#endif
                case PropertyType.Integer:
                    if (rect.HasValue)
                    {
                        value = EditorGUI.IntField(rect.Value, nameContent, (int)(value ?? 0));
                    }
                    else
                    {
                        value = EditorGUILayout.IntField(nameContent, (int)(value ?? 0));
                    }
                    break;

                case PropertyType.Double:
#if UNITY_5
                    if (rect.HasValue)
                    {
                        value = EditorGUI.DoubleField(rect.Value, nameContent, (double)(value ?? 0));
                    }
                    else
                    {
                        value = EditorGUILayout.DoubleField(nameContent, (double)(value ?? 0));
                    }
                    break;
#endif
                case PropertyType.Single:
                    if (rect.HasValue)
                    {
                        value = EditorGUI.FloatField(rect.Value, nameContent, (float)(value ?? 0F));
                    }
                    else
                    {
                        value = EditorGUILayout.FloatField(nameContent, (float)(value ?? 0F));
                    }
                    break;

                case PropertyType.Vector2:
                    if (rect.HasValue)
                    {
                        value = EditorGUI.Vector2Field(rect.Value, nameContent, (Vector2)(value ?? Vector2.zero));
                    }
                    else
                    {
                        value = EditorGUILayout.Vector2Field(nameContent, (Vector2)(value ?? Vector2.zero));
                    }
                    break;

                case PropertyType.Vector3:
                    if (rect.HasValue)
                    {
                        value = EditorGUI.Vector3Field(rect.Value, nameContent, (Vector3)(value ?? Vector3.zero));
                    }
                    else
                    {
                        value = EditorGUILayout.Vector3Field(nameContent, (Vector3)(value ?? Vector3.zero));
                    }
                    break;

                case PropertyType.Vector4:
                    if (rect.HasValue)
                    {
                        value = EditorGUI.Vector4Field(rect.Value, name, (Vector4)(value ?? Vector4.zero));
                    }
                    else
                    {
                        value = EditorGUILayout.Vector4Field(name, (Vector4)(value ?? Vector4.zero));
                    }
                    break;

                case PropertyType.Quaterion:
                    if (rect.HasValue)
                    {
                        value = Helper.QuaternionField(rect.Value, name, (Quaternion)(value ?? Quaternion.identity));
                    }
                    else
                    {
                        value = Helper.QuaternionField(name, (Quaternion)(value ?? Quaternion.identity));
                    }
                    break;

                case PropertyType.Color:
                    if (rect.HasValue)
                    {
                        value = EditorGUI.ColorField(rect.Value, nameContent, (Color)(value ?? Color.white));
                    }
                    else
                    {
                        value = EditorGUILayout.ColorField(nameContent, (Color)(value ?? Color.white));
                    }
                    break;

                case PropertyType.Rect:
                    if (rect.HasValue)
                    {
                        value = EditorGUI.RectField(rect.Value, nameContent, (Rect)(value ?? default(Rect)));
                    }
                    else
                    {
                        value = EditorGUILayout.RectField(nameContent, (Rect)(value ?? default(Rect)));
                    }
                    break;

                case PropertyType.Bounds:
                    if (rect.HasValue)
                    {
                        value = EditorGUI.BoundsField(rect.Value, nameContent, (Bounds)(value ?? default(Bounds)));
                    }
                    else
                    {
                        value = EditorGUILayout.BoundsField(nameContent, (Bounds)(value ?? default(Bounds)));
                    }
                    break;

                case PropertyType.Curve:
                    if (rect.HasValue)
                    {
                        value = EditorGUI.CurveField(rect.Value, nameContent, (AnimationCurve)(value ?? new AnimationCurve()));
                    }
                    else
                    {
                        value = EditorGUILayout.CurveField(nameContent, (AnimationCurve)(value ?? new AnimationCurve()));
                    }
                    break;

                case PropertyType.Object:
                    if (rect.HasValue)
                    {
                        value = Helper.ObjectField(rect.Value, nameContent, (UnityObject)value, requiredType, true, readOnly);
                    }
                    else
                    {
                        value = Helper.ObjectField(nameContent, (UnityObject)value, requiredType, true, readOnly);
                    }
                    break;

                case PropertyType.Array:
                    if (rect.HasValue)
                    {
                        arrayHandler.DoList(rect.Value);
                        break;
                    }
                    EditorGUILayout.BeginVertical();
                    if (arrayShown = EditorGUILayout.Foldout(arrayShown, nameContent))
                    {
                        arrayHandler.DoLayoutList();
                    }
                    EditorGUILayout.EndVertical();
                    break;

                case PropertyType.String:
                    if (rect.HasValue)
                    {
                        value = Helper.StringField(rect.Value, nameContent, (string)value, readOnly);
                    }
                    else
                    {
                        value = Helper.StringField(nameContent, (string)value, readOnly);
                    }
                    break;

                default:
                    var stringValue = value != null?value.ToString() : "Null";

                    if (rect.HasValue)
                    {
                        Helper.StringField(Helper.ScaleRect(rect.Value, 0, 0, 1, 1, 0, 0, -36), nameContent, stringValue, true);
                        DrawUnknownField(readOnly, value, Helper.ScaleRect(rect.Value, 1, 0, 0, 1, -34, 0, 32));
                    }
                    else
                    {
                        Helper.StringField(nameContent, stringValue, true);
                        DrawUnknownField(readOnly, value);
                    }
                    break;
                }
            } catch (InvalidCastException) {
                if (Event.current.type == EventType.Repaint)
                {
                    value = null;
                }
                else
                {
                    RequireRedraw();
                }
            }
            if (!readOnly)
            {
                changed |= GUI.changed;
                rawValue = value;
            }
        }
        /// <summary>
        /// Helper method for rendering various controls.
        /// </summary>
        /// <param name="type"></param>
        /// <param name="value"></param>
        /// <param name="content"></param>
        public static int AnyField(Rect rect, Type type, ref object value, GUIContent content)
        {
            if (type == typeof(bool))
            {
                value = EditorGUI.Toggle(rect, content, (bool)value);
            }
            else if (type == typeof(byte))
            {
                value = (byte)EditorGUI.DelayedIntField(rect, content, (byte)value);
            }
            else if (type == typeof(short))
            {
                value = (short)EditorGUI.DelayedIntField(rect, content, (short)value);
            }
            else if (type == typeof(ushort))
            {
                value = (ushort)EditorGUI.DelayedIntField(rect, content, (ushort)value);
            }
            else if (type == typeof(int))
            {
                value = EditorGUI.IntField(rect, content, (int)value);
            }
            else if (type == typeof(uint))
            {
                value = (uint)EditorGUI.IntField(rect, content, (int)value);
            }
            else if (type == typeof(long))
            {
                value = EditorGUI.LongField(rect, content, (long)value);
            }
            else if (type == typeof(ulong))
            {
                value = (ulong)EditorGUI.LongField(rect, content, (long)value);
            }
            else if (type == typeof(float))
            {
                value = EditorGUI.FloatField(rect, content, (float)value);
            }
            else if (type == typeof(double))
            {
                value = EditorGUI.DoubleField(rect, content, (double)value);
            }
            else if (type == typeof(string))
            {
                value = EditorGUI.TextField(rect, content, (string)value);
            }
            else if (TypeHelper.IsSameOrSubclass(typeof(Enum), type))
            {
                value = EditorGUI.EnumPopup(rect, content, (Enum)value);
            }
            else if (type == typeof(Vector2))
            {
                value = EditorGUI.Vector2Field(rect, content, (Vector2)value);
            }
            else if (type == typeof(Vector3))
            {
                value = EditorGUI.Vector3Field(rect, content, (Vector3)value);
            }
            else if (type == typeof(Vector4))
            {
                value = EditorGUI.Vector4Field(rect, content, (Vector4)value);
            }
            else if (type == typeof(Quaternion))
            {
                Quaternion q = (Quaternion)value;
                q.eulerAngles = EditorGUI.Vector3Field(rect, content, ((Quaternion)value).eulerAngles);
                value         = q;
            }
            else if (type == typeof(Color))
            {
                value = EditorGUI.ColorField(rect, content, (Color)value);
            }
            else if (type == typeof(Bounds))
            {
                value = EditorGUI.BoundsField(rect, content, (Bounds)value);
            }
            else if (type == typeof(Rect))
            {
                value = EditorGUI.RectField(rect, content, (Rect)value);
            }
            else if (type == typeof(AnimationCurve))
            {
                value = EditorGUI.CurveField(rect, content, (AnimationCurve)value);
            }
            else if (TypeHelper.IsSameOrSubclass(typeof(UnityEngine.Object), type))
            {
                value = EditorGUI.ObjectField(rect, content, (UnityEngine.Object)value, type, true);
            }
            else if (type == typeof(LayerMask))
            {
                value = LayerMaskField(content, (LayerMask)value);
            }
            else
            {
                return(ComplexField(rect, content, value));
            }
            //TODO: general EnumMask, Assets (Sprite, Texture, etc...)

            return(1);
        }
示例#28
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;
        }
    }
        /// <summary>
        /// Shows an object field editor for object types that do no derive from UnityEngine.Object.
        /// </summary>
        /// <typeparam name="T">Type of the object to modify.</typeparam>
        /// <param name="position">The region to show the UI.</param>
        /// <param name="label">Label to show.</param>
        /// <param name="value">Current value to show.</param>
        /// <param name="allowSceneObjects">Whether scene objects should be allowed in the set of field choices.</param>
        /// <returns>The new value.</returns>
        public static T ObjectField <T>(Rect position, GUIContent label, T value, bool allowSceneObjects)
        {
            object objValue = value;

            Type valueType = objValue.GetType();

            if (valueType == typeof(Bounds))
            {
                objValue = EditorGUI.BoundsField(position, label, (Bounds)objValue);
            }
            else if (valueType == typeof(Color))
            {
                objValue = EditorGUI.ColorField(position, label, (Color)objValue);
            }
            else if (valueType == typeof(Material))
            {
                objValue = EditorGUI.ObjectField(position, (Material)objValue, typeof(Material), allowSceneObjects);
            }
            else if (valueType == typeof(AnimationCurve))
            {
                objValue = EditorGUI.CurveField(position, label, (AnimationCurve)objValue);
            }
            else if (valueType == typeof(float))
            {
                objValue = EditorGUI.FloatField(position, label, (float)objValue);
            }
            else if (valueType == typeof(int))
            {
                objValue = EditorGUI.IntField(position, label, (int)objValue);
            }
            else if (valueType == typeof(LayerMask))
            {
                objValue = EditorGUI.MaskField(position, label, (LayerMask)objValue, LayerMaskExtensions.LayerMaskNames);
            }
            else if (valueType.IsEnum)
            {
                if (valueType.GetCustomAttributes(typeof(FlagsAttribute), true).Length > 0)
                {
                    objValue = EditorGUI.EnumFlagsField(position, label, (Enum)objValue);
                }
                else
                {
                    objValue = EditorGUI.EnumPopup(position, label, (Enum)objValue);
                }
            }
            else if (valueType == typeof(Rect))
            {
                objValue = EditorGUI.RectField(position, label, (Rect)objValue);
            }
            else if (valueType == typeof(string))
            {
                objValue = EditorGUI.TextField(position, label, (string)objValue);
            }
            else if (valueType == typeof(Vector2))
            {
                objValue = EditorGUI.Vector2Field(position, new GUIContent(), (Vector2)objValue);
            }
            else if (valueType == typeof(Vector3))
            {
                objValue = EditorGUI.Vector3Field(position, new GUIContent(), (Vector3)objValue);
            }
            else if (valueType == typeof(Vector4))
            {
                if (label.image != null)
                {
                    throw new ArgumentException("Images not supported for labels of Vector4 fields.", "label");
                }

                if (!string.IsNullOrEmpty(label.tooltip))
                {
                    throw new ArgumentException("Tool-tips not supported for labels of Vector4 fields.", "label");
                }

                objValue = EditorGUI.Vector4Field(position, label.text, (Vector4)objValue);
            }
            else if (Equals(objValue, typeof(SceneAsset)))
            {
                objValue = EditorGUI.ObjectField(position, (SceneAsset)objValue, typeof(SceneAsset), allowSceneObjects);
            }
            else if (objValue is UnityEngine.Object)
            {
                objValue = EditorGUI.ObjectField(position, label, (UnityEngine.Object)objValue, valueType, allowSceneObjects);
            }
            else
            {
                throw new ArgumentException(
                          string.Format(
                              CultureInfo.InvariantCulture,
                              "Unimplemented value type: {0}.",
                              valueType),
                          "value");
            }

            return((T)objValue);
        }
 public override Bounds Edit(Rect region, GUIContent label, Bounds element, fiGraphMetadata metadata)
 {
     return(EditorGUI.BoundsField(region, label, element));
 }