public override void Draw(Rect position, SerializedProperty property, GUIContent label)
{
var expanded = property.isExpanded;
var definition = ValueDefinition.Create((VariableType)_typeProperty.enumValueIndex, _constraint, null, null, _isTypeLockedProperty.boolValue, _isConstraintLockedProperty.boolValue);
definition = Draw(position, label, definition, VariableInitializerType.None, null, true, ref expanded);
_typeProperty.enumValueIndex = (int)definition.Type;
_constraint = definition.Constraint;
_constraintProperty.stringValue = _constraint != null?VariableHandler.SaveConstraint(definition.Type, _constraint, ref _objects) : string.Empty;
if (_objects != null)
{
_objectsProperty.arraySize = _objects.Count;
for (var i = 0; i < _objects.Count; i++)
{
_objectsProperty.GetArrayElementAtIndex(i).objectReferenceValue = _objects[i];
}
}
else
{
_objectsProperty.arraySize = 0;
}
property.isExpanded = expanded;
}
private static void DrawStoreConstraint(Rect rect, ref VariableConstraint constraint)
{
if (!(constraint is StoreVariableConstraint storeConstraint))
{
storeConstraint = new StoreVariableConstraint {
Schema = null
};
constraint = storeConstraint;
}
storeConstraint.Schema = AssetDisplayDrawer.Draw(rect, GUIContent.none, storeConstraint.Schema, false, false, AssetLocation.None, null);
}
private static void DrawObjectConstraint(Rect rect, ref VariableConstraint constraint)
{
if (!(constraint is ObjectVariableConstraint objectConstraint))
{
objectConstraint = new ObjectVariableConstraint {
Type = typeof(Object)
};
constraint = objectConstraint;
}
objectConstraint.Type = TypeDisplayDrawer.Draw <Object>(rect, GUIContent.none, objectConstraint.Type, false, true);
}
private static void DrawEnumConstraint(Rect rect, ref VariableConstraint constraint)
{
if (!(constraint is EnumVariableConstraint enumConstraint))
{
enumConstraint = new EnumVariableConstraint {
Type = null
};
constraint = enumConstraint;
}
enumConstraint.Type = TypeDisplayDrawer.Draw <Enum>(rect, GUIContent.none, enumConstraint.Type, false, true);
}
private static float GetConstraintHeight(VariableType type, VariableConstraint constraint)
{
var height = RectHelper.LineHeight;
if (type == VariableType.List && constraint is ListVariableConstraint listConstraint)
{
if (HasConstraint(listConstraint.ItemType, listConstraint.ItemConstraint, false))
{
height += GetConstraintHeight(listConstraint.ItemType, listConstraint.ItemConstraint);
}
}
else if (type == VariableType.String && constraint is StringVariableConstraint stringConstraint)
{
height = (1 + stringConstraint.Values.Length) * RectHelper.LineHeight;
}
return(height);
}
public override void Setup(SerializedProperty property, FieldInfo fieldInfo, PropertyAttribute attribute)
{
_typeProperty = property.FindPropertyRelative("_type");
_constraintProperty = property.FindPropertyRelative("_constraint");
_objectsProperty = property.FindPropertyRelative("_objects");
_isTypeLockedProperty = property.FindPropertyRelative("_isTypeLocked");
_isConstraintLockedProperty = property.FindPropertyRelative("_isConstraintLocked");
var data = _constraintProperty.stringValue;
_objects = new List <Object>();
for (var i = 0; i < _objectsProperty.arraySize; i++)
{
_objects.Add(_objectsProperty.GetArrayElementAtIndex(i).objectReferenceValue);
}
_constraint = VariableHandler.LoadConstraint(ref data, ref _objects);
}
private static void DrawListConstraint(Rect rect, ref VariableConstraint constraint)
{
if (!(constraint is ListVariableConstraint listConstraint))
{
listConstraint = new ListVariableConstraint {
ItemType = VariableType.Empty, ItemConstraint = null
};
constraint = listConstraint;
}
var typeRect = RectHelper.TakeLine(ref rect);
listConstraint.ItemType = (VariableType)EditorGUI.EnumPopup(typeRect, listConstraint.ItemType);
if (HasConstraint(listConstraint.ItemType, listConstraint.ItemConstraint, false))
{
DrawConstraint(rect, listConstraint.ItemType, false, ref listConstraint.ItemConstraint, false);
}
}
private static void DrawStringConstraint(Rect rect, ref VariableConstraint constraint)
{
if (!(constraint is StringVariableConstraint stringConstraint))
{
stringConstraint = new StringVariableConstraint {
Values = new string[] { }
};
constraint = stringConstraint;
}
var remove = -1;
for (var i = 0; i < stringConstraint.Values.Length; i++)
{
if (i != 0)
{
RectHelper.TakeVerticalSpace(ref rect);
}
var item = stringConstraint.Values[i];
var itemRect = RectHelper.TakeLine(ref rect);
var removeRect = RectHelper.TakeTrailingIcon(ref itemRect);
stringConstraint.Values[i] = EditorGUI.TextField(itemRect, item);
if (GUI.Button(removeRect, _removeButton.Content, GUIStyle.none))
{
remove = i;
}
}
var addRect = RectHelper.TakeTrailingIcon(ref rect);
if (GUI.Button(addRect, _addButton.Content, GUIStyle.none))
{
ArrayUtility.Add(ref stringConstraint.Values, string.Empty);
}
if (remove >= 0)
{
ArrayUtility.RemoveAt(ref stringConstraint.Values, remove);
}
}
private static bool HasConstraint(VariableType type, VariableConstraint constraint, bool isConstraintLocked)
{
if (!isConstraintLocked)
{
switch (type)
{
case VariableType.Int:
case VariableType.Float:
case VariableType.String:
case VariableType.Enum:
case VariableType.Object:
case VariableType.Store:
case VariableType.List: return(true);
default: return(false);
}
}
else
{
return(constraint != null);
}
}
private static void DrawNumberConstraint(Rect rect, VariableType type, ref VariableConstraint constraint)
{
var fromLabel = _minimumConstraintLabel;
var toLabel = _maximumConstraintLabel;
var fromSize = EditorStyles.label.CalcSize(fromLabel);
var toSize = EditorStyles.label.CalcSize(toLabel);
var spacing = 5.0f;
var inputWidth = (rect.width - rect.height - fromSize.x - toSize.x - spacing * 4) * 0.5f;
var checkboxRect = RectHelper.TakeWidth(ref rect, rect.height);
RectHelper.TakeWidth(ref rect, spacing);
var fromRect = RectHelper.TakeWidth(ref rect, fromSize.x);
RectHelper.TakeWidth(ref rect, spacing);
var minimumRect = RectHelper.TakeWidth(ref rect, inputWidth);
RectHelper.TakeWidth(ref rect, spacing);
var toRect = RectHelper.TakeWidth(ref rect, toSize.x);
RectHelper.TakeWidth(ref rect, spacing);
var maximumRect = RectHelper.TakeWidth(ref rect, inputWidth);
var useRangeConstraint = GUI.Toggle(checkboxRect, constraint != null, _useRangeConstraintLabel);
if (!useRangeConstraint)
{
constraint = null;
}
else if (type == VariableType.Int)
{
if (!(constraint is IntVariableConstraint intConstraint))
{
intConstraint = new IntVariableConstraint {
Minimum = 0, Maximum = 100
};
constraint = intConstraint;
}
GUI.Label(fromRect, fromLabel);
intConstraint.Minimum = EditorGUI.IntField(minimumRect, intConstraint.Minimum);
GUI.Label(toRect, toLabel);
intConstraint.Maximum = EditorGUI.IntField(maximumRect, intConstraint.Maximum);
}
else if (type == VariableType.Float)
{
if (!(constraint is FloatVariableConstraint floatConstraint))
{
floatConstraint = new FloatVariableConstraint {
Minimum = 0, Maximum = 100
};
constraint = floatConstraint;
}
GUI.Label(fromRect, fromLabel);
floatConstraint.Minimum = EditorGUI.FloatField(minimumRect, floatConstraint.Minimum);
GUI.Label(toRect, toLabel);
floatConstraint.Maximum = EditorGUI.FloatField(maximumRect, floatConstraint.Maximum);
}
}
private static void DrawConstraint(Rect rect, VariableType type, bool isConstraintLocked, ref VariableConstraint constraint, bool top)
{
RectHelper.TakeTrailingHeight(ref rect, RectHelper.VerticalSpace);
using (new EditorGUI.DisabledScope(isConstraintLocked))
{
switch (type)
{
case VariableType.Int:
case VariableType.Float:
{
if (top)
{
DrawIndentedLabel(ref rect, _numberConstraintLabel);
}
DrawNumberConstraint(rect, type, ref constraint);
break;
}
case VariableType.String:
{
if (top)
{
DrawIndentedLabel(ref rect, _stringConstraintLabel);
}
DrawStringConstraint(rect, ref constraint);
break;
}
case VariableType.Object:
{
if (top)
{
DrawIndentedLabel(ref rect, _objectConstraintLabel);
}
DrawObjectConstraint(rect, ref constraint);
break;
}
case VariableType.Enum:
{
if (top)
{
DrawIndentedLabel(ref rect, _enumConstraintLabel);
}
DrawEnumConstraint(rect, ref constraint);
break;
}
case VariableType.Store:
{
if (top)
{
DrawIndentedLabel(ref rect, _storeConstraintLabel);
}
DrawStoreConstraint(rect, ref constraint);
break;
}
case VariableType.List:
{
if (top)
{
DrawIndentedLabel(ref rect, _listConstraintLabel);
}
DrawListConstraint(rect, ref constraint);
break;
}
}
}
}
