public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
if (EditorHelper.AssertMultiObjectEditingNotSupported(position, property, label))
{
return;
}
if (property.isArray)
{
if (_disallowFoldout)
{
this.StartOnGUI(property, label);
//_lst.DoList(EditorGUI.IndentedRect(position));
_lst.DoList(position);
this.EndOnGUI(property, label);
}
else
{
const float WIDTH_FOLDOUT = 5f;
if (property.isExpanded)
{
this.StartOnGUI(property, label);
property.isExpanded = EditorGUI.Foldout(new Rect(position.xMin, position.yMin, WIDTH_FOLDOUT, EditorGUIUtility.singleLineHeight), property.isExpanded, GUIContent.none);
//_lst.DoList(EditorGUI.IndentedRect(position));
_lst.DoList(position);
this.EndOnGUI(property, label);
}
else
{
if (_removeBackgroundWhenCollapsed)
{
property.isExpanded = EditorGUI.Foldout(position, property.isExpanded, label);
}
else
{
property.isExpanded = EditorGUI.Foldout(new Rect(position.xMin, position.yMin, WIDTH_FOLDOUT, EditorGUIUtility.singleLineHeight), property.isExpanded, GUIContent.none);
//ReorderableListHelper.DrawRetractedHeader(EditorGUI.IndentedRect(position), label);
ReorderableListHelper.DrawRetractedHeader(position, label);
}
}
}
if (_drawElementAtBottom && _lst.index >= 0 && _lst.index < property.arraySize)
{
var pchild = property.GetArrayElementAtIndex(_lst.index);
var label2 = TempElementLabel(pchild, _lst.index); //(string.IsNullOrEmpty(_childPropertyAsLabel)) ? TempElementLabel(_lst.index) : GUIContent.none;
pchild.isExpanded = true;
float h;
if (_internalDrawer != null)
{
h = _internalDrawer.GetPropertyHeight(pchild, label2) + BOTTOM_PAD + TOP_PAD;
}
else
{
h = SPEditorGUI.GetDefaultPropertyHeight(pchild, label2, true) + BOTTOM_PAD + TOP_PAD;
}
var area = new Rect(position.x, position.yMax - h, position.width, h);
var drawArea = new Rect(area.x, area.y + TOP_PAD, area.width, area.height - TOP_PAD);
GUI.BeginGroup(area, label2, GUI.skin.box);
GUI.EndGroup();
if (_internalDrawer != null)
{
_internalDrawer.OnGUI(drawArea, pchild, label2);
}
else
{
SPEditorGUI.DefaultPropertyField(drawArea, pchild, GUIContent.none, true);
}
}
}
else
{
EditorGUI.PropertyField(position, property, label, false);
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
var prop_min = property.FindPropertyRelative(PROP_MIN);
var prop_max = property.FindPropertyRelative(PROP_MAX);
var attrib = this.fieldInfo.GetCustomAttributes(typeof(Interval.ConfigAttribute), false).Cast <Interval.ConfigAttribute>().FirstOrDefault();
bool reverse = (attrib != null) ? attrib.Reverse : false;
float minValue = (attrib != null) ? attrib.MinValue : float.NegativeInfinity;
float maxValue = (attrib != null) ? attrib.MaxValue : float.PositiveInfinity;
bool discreteValuesOnly = (attrib != null) ? attrib.DiscreteValuesOnly : false;
GUIContent[] subLabels;
float labelWidth;
if (reverse)
{
subLabels = (attrib != null) ? new GUIContent[] { EditorHelper.TempContent(attrib.MaxLabel), EditorHelper.TempContent(attrib.MinLabel) } : _defaultLabels;
labelWidth = (attrib != null) ? attrib.LabelWidth : 30f;
_values[1] = prop_min.floatValue;
_values[0] = prop_max.floatValue;
}
else
{
subLabels = (attrib != null) ? new GUIContent[] { EditorHelper.TempContent(attrib.MinLabel), EditorHelper.TempContent(attrib.MaxLabel) } : _defaultLabels;
labelWidth = (attrib != null) ? attrib.LabelWidth : 30f;
_values[0] = prop_min.floatValue;
_values[1] = prop_max.floatValue;
}
EditorGUI.BeginProperty(position, label, property);
EditorGUI.BeginChangeCheck();
SPEditorGUI.DelayedMultiFloatField(position, label, subLabels, _values, labelWidth);
if (EditorGUI.EndChangeCheck())
{
_values[0] = Mathf.Clamp(_values[0], minValue, maxValue);
_values[1] = Mathf.Clamp(_values[1], minValue, maxValue);
if (discreteValuesOnly)
{
_values[0] = Mathf.Round(_values[0]);
}
if (discreteValuesOnly)
{
_values[1] = Mathf.Round(_values[1]);
}
float min = reverse ? _values[1] : _values[0];
float max = reverse ? _values[0] : _values[1];
if (!MathUtil.FuzzyEqual(min, prop_min.floatValue))
{
//changed min
if (max < min)
{
max = min;
}
}
else
{
//changed max
if (min > max)
{
min = max;
}
}
prop_min.floatValue = min;
prop_max.floatValue = max;
}
EditorGUI.EndProperty();
}
private CachedReorderableList GetList(SerializedProperty property, GUIContent label)
{
var lst = CachedReorderableList.GetListDrawer(property, _maskList_DrawHeader, _maskList_DrawElement);
lst.draggable = _draggable;
if (property.arraySize > 0)
{
var pchild = property.GetArrayElementAtIndex(0);
lst.elementHeight = (_internalDrawer != null) ? _internalDrawer.GetPropertyHeight(pchild, label) : SPEditorGUI.GetDefaultPropertyHeight(pchild, label) + 1;
}
else
{
lst.elementHeight = EditorGUIUtility.singleLineHeight;
}
return(lst);
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
this.Init(property);
EditorGUI.BeginProperty(position, label, property);
//################################
//FIRST LINE
var rect = new Rect(position.xMin, position.yMin, position.width, EditorGUIUtility.singleLineHeight);
var configProp = property.FindPropertyRelative(PROP_CONFIGURED);
var targetProp = property.FindPropertyRelative(PROP_TARGET);
var findProp = property.FindPropertyRelative(PROP_FIND);
//var r0 = new Rect(rect.xMin, rect.yMin, EditorGUIUtility.labelWidth, rect.height);
//rect = new Rect(r0.xMax, rect.yMin, rect.width - r0.width, rect.height);
//property.isExpanded = EditorGUI.Foldout(r0, property.isExpanded, label);
if (!this.AlwaysExpanded)
{
property.isExpanded = SPEditorGUI.PrefixFoldoutLabel(ref rect, property.isExpanded, label);
}
else
{
rect = EditorGUI.PrefixLabel(rect, label);
}
var r0 = new Rect(rect.xMin, rect.yMin, Mathf.Min(rect.width * 0.25f, 50f), rect.height);
var e = (configProp.boolValue) ? TargetSource.Config : TargetSource.Arg;
EditorGUI.BeginChangeCheck();
e = (TargetSource)EditorGUI.EnumPopup(r0, e);
if (EditorGUI.EndChangeCheck())
{
UpdateTargetFromSource(targetProp, e);
configProp.boolValue = (e != TargetSource.Arg);
if (e != TargetSource.Arg)
{
findProp.SetEnumValue(TriggerableTargetObject.FindCommand.Direct);
}
}
else if (e == TargetSource.Config && !_defaultSet && targetProp.objectReferenceValue == null)
{
UpdateTargetFromSource(targetProp, e);
_defaultSet = true;
}
else
{
_defaultSet = true;
}
var r1 = new Rect(rect.xMin + r0.width, rect.yMin, rect.width - r0.width, rect.height);
if (!configProp.boolValue)
{
var e0 = findProp.GetEnumValue <TriggerableTargetObject.FindCommand>();
switch (e0)
{
case TriggerableTargetObject.FindCommand.Direct:
EditorGUI.LabelField(r1, "Target determined by activating trigger.");
break;
case TriggerableTargetObject.FindCommand.FindParent:
case TriggerableTargetObject.FindCommand.FindInChildren:
case TriggerableTargetObject.FindCommand.FindInEntity:
EditorGUI.LabelField(r1, e0.ToString() + " of activating trigger arg.");
break;
case TriggerableTargetObject.FindCommand.FindInScene:
case TriggerableTargetObject.FindCommand.FindEntityInScene:
default:
configProp.boolValue = false;
targetProp.objectReferenceValue = null;
EditorGUI.LabelField(r1, e0.ToString());
break;
}
targetProp.objectReferenceValue = null;
}
else
{
_objectDrawer.OnGUI(r1, targetProp, GUIContent.none);
}
//################################
//SECOND LINE
if (this.AlwaysExpanded || property.isExpanded)
{
var indent = EditorGUIUtility.labelWidth * 0.5f;
rect = new Rect(position.xMin + indent, position.yMin + EditorGUIUtility.singleLineHeight, Mathf.Max(0f, position.width - indent), EditorGUIUtility.singleLineHeight);
var w0 = Mathf.Min(rect.width * 0.3f, 120f);
var w1 = Mathf.Min(rect.width * 0.3f, 80f);
var w2 = rect.width - w0 - w1;
r0 = new Rect(rect.xMin, rect.yMin, w0, rect.height);
r1 = new Rect(r0.xMax, rect.yMin, w1, rect.height);
var r2 = new Rect(r1.xMax, rect.yMin, w2, rect.height);
var resolveProp = property.FindPropertyRelative(PROP_RESOLVEBY);
var queryProp = property.FindPropertyRelative(PROP_QUERY);
var e0 = findProp.GetEnumValue <TriggerableTargetObject.FindCommand>();
EditorGUI.BeginChangeCheck();
e0 = (TriggerableTargetObject.FindCommand)EditorGUI.EnumPopup(r0, e0);
if (EditorGUI.EndChangeCheck())
{
findProp.SetEnumValue(e0);
}
switch (e0)
{
case TriggerableTargetObject.FindCommand.FindInScene:
case TriggerableTargetObject.FindCommand.FindEntityInScene:
configProp.boolValue = false;
targetProp.objectReferenceValue = null;
break;
}
var e1 = resolveProp.GetEnumValue <TriggerableTargetObject.ResolveByCommand>();
EditorGUI.BeginChangeCheck();
e1 = (TriggerableTargetObject.ResolveByCommand)EditorGUI.EnumPopup(r1, e1);
if (EditorGUI.EndChangeCheck())
{
resolveProp.SetEnumValue(e1);
}
switch (e1)
{
case TriggerableTargetObject.ResolveByCommand.Nothing:
{
var cache = SPGUI.Disable();
EditorGUI.TextField(r2, string.Empty);
queryProp.stringValue = string.Empty;
cache.Reset();
}
break;
case TriggerableTargetObject.ResolveByCommand.WithTag:
{
queryProp.stringValue = EditorGUI.TagField(r2, queryProp.stringValue);
}
break;
case TriggerableTargetObject.ResolveByCommand.WithName:
{
queryProp.stringValue = EditorGUI.TextField(r2, queryProp.stringValue);
}
break;
case TriggerableTargetObject.ResolveByCommand.WithType:
{
var tp = TypeUtil.FindType(queryProp.stringValue);
if (!TypeUtil.IsType(tp, typeof(UnityEngine.Object)))
{
tp = null;
}
tp = SPEditorGUI.TypeDropDown(r2, GUIContent.none, typeof(UnityEngine.Object), tp);
queryProp.stringValue = (tp != null) ? tp.FullName : null;
}
break;
}
}
EditorGUI.EndProperty();
}
private void _dataList_DrawElement(Rect area, int index, bool isActive, bool isFocused)
{
Rect position;
var el = _dataList.serializedProperty.GetArrayElementAtIndex(index);
position = CalcNextRect(ref area);
SPEditorGUI.PropertyField(position, el.FindPropertyRelative(PROP_DATA_MODE));
//TODO - member
position = CalcNextRect(ref area);
var memberProp = el.FindPropertyRelative(PROP_DATA_MEMBER);
System.Type propType;
memberProp.stringValue = i_TweenValueInspector.ReflectedPropertyAndCustomTweenAccessorField(position,
EditorHelper.TempContent("Property", "The property on the target to set."),
_targetProp.objectReferenceValue,
memberProp.stringValue,
com.spacepuppy.Dynamic.DynamicMemberAccess.ReadWrite,
out propType);
position = CalcNextRect(ref area);
SPEditorGUI.PropertyField(position, el.FindPropertyRelative(PROP_DATA_EASE));
position = CalcNextRect(ref area);
SPEditorGUI.PropertyField(position, el.FindPropertyRelative(PROP_DATA_DUR));
if (propType != null)
{
switch (el.FindPropertyRelative(PROP_DATA_MODE).GetEnumValue <TweenHash.AnimMode>())
{
case TweenHash.AnimMode.To:
{
position = CalcNextRect(ref area);
this.DrawVariant(position, EditorHelper.TempContent("To Value"), propType, el.FindPropertyRelative(PROP_DATA_VALUES));
position = CalcNextRect(ref area);
}
break;
case TweenHash.AnimMode.From:
{
position = CalcNextRect(ref area);
this.DrawVariant(position, EditorHelper.TempContent("From Value"), propType, el.FindPropertyRelative(PROP_DATA_VALUES));
}
break;
case TweenHash.AnimMode.By:
{
position = CalcNextRect(ref area);
this.DrawVariant(position, EditorHelper.TempContent("By Value"), propType, el.FindPropertyRelative(PROP_DATA_VALUES));
}
break;
case TweenHash.AnimMode.FromTo:
{
position = CalcNextRect(ref area);
this.DrawVariant(position, EditorHelper.TempContent("Start Value"), propType, el.FindPropertyRelative(PROP_DATA_VALUES));
position = CalcNextRect(ref area);
this.DrawVariant(position, EditorHelper.TempContent("End Value"), propType, el.FindPropertyRelative(PROP_DATA_VALUEE));
}
break;
case TweenHash.AnimMode.RedirectTo:
{
position = CalcNextRect(ref area);
this.DrawVariant(position, EditorHelper.TempContent("Start Value"), propType, el.FindPropertyRelative(PROP_DATA_VALUES));
position = CalcNextRect(ref area);
this.DrawVariant(position, EditorHelper.TempContent("End Value"), propType, el.FindPropertyRelative(PROP_DATA_VALUEE));
}
break;
}
}
}
private void DrawValueFieldInValueMode(Rect position, SerializedProperty property, VariantReference.EditorHelper helper)
{
if (helper.Target == null)
{
return;
}
var variant = helper.Target;
if (this.RestrictVariantType && helper._type != this.VariantTypeRestrictedTo)
{
helper.PrepareForValueTypeChange(this.VariantTypeRestrictedTo);
GUI.changed = true; //force change
}
var r0 = new Rect(position.xMin, position.yMin, 90.0f, EditorGUIUtility.singleLineHeight);
var r1 = new Rect(r0.xMax, position.yMin, position.xMax - r0.xMax, EditorGUIUtility.singleLineHeight);
var cache = SPGUI.DisableIf(this.RestrictVariantType);
EditorGUI.BeginChangeCheck();
var valueType = (VariantType)EditorGUI.EnumPopup(r0, GUIContent.none, variant.ValueType);
if (EditorGUI.EndChangeCheck())
{
helper.PrepareForValueTypeChange(valueType);
}
cache.Reset();
if (_typeRestrictedTo.IsEnum)
{
variant.IntValue = ConvertUtil.ToInt(EditorGUI.EnumPopup(r1, ConvertUtil.ToEnumOfType(_typeRestrictedTo, variant.IntValue)));
}
else
{
switch (valueType)
{
case VariantType.Null:
cache = SPGUI.Disable();
EditorGUI.TextField(r1, "Null");
cache.Reset();
break;
case VariantType.String:
variant.StringValue = EditorGUI.TextField(r1, variant.StringValue);
break;
case VariantType.Boolean:
variant.BoolValue = EditorGUI.Toggle(r1, variant.BoolValue);
break;
case VariantType.Integer:
variant.IntValue = EditorGUI.IntField(r1, variant.IntValue);
break;
case VariantType.Float:
variant.FloatValue = EditorGUI.FloatField(r1, variant.FloatValue);
break;
case VariantType.Double:
variant.DoubleValue = ConvertUtil.ToDouble(EditorGUI.TextField(r1, variant.DoubleValue.ToString()));
break;
case VariantType.Vector2:
variant.Vector2Value = EditorGUI.Vector2Field(r1, GUIContent.none, variant.Vector2Value);
break;
case VariantType.Vector3:
variant.Vector3Value = EditorGUI.Vector3Field(r1, GUIContent.none, variant.Vector3Value);
break;
case VariantType.Vector4:
variant.Vector4Value = EditorGUI.Vector4Field(r1, (string)null, variant.Vector4Value);
break;
case VariantType.Quaternion:
variant.QuaternionValue = SPEditorGUI.QuaternionField(r1, GUIContent.none, variant.QuaternionValue);
break;
case VariantType.Color:
variant.ColorValue = EditorGUI.ColorField(r1, variant.ColorValue);
break;
case VariantType.DateTime:
variant.DateValue = ConvertUtil.ToDate(EditorGUI.TextField(r1, variant.DateValue.ToString()));
break;
case VariantType.GameObject:
variant.GameObjectValue = EditorGUI.ObjectField(r1, variant.GameObjectValue, typeof(GameObject), true) as GameObject;
break;
case VariantType.Component:
{
_selectComponentDrawer.AllowNonComponents = false;
_selectComponentDrawer.RestrictionType = _forcedObjectType;
_selectComponentDrawer.ShowXButton = true;
var targProp = property.FindPropertyRelative("_unityObjectReference");
EditorGUI.BeginChangeCheck();
_selectComponentDrawer.OnGUI(r1, targProp);
if (EditorGUI.EndChangeCheck())
{
variant.ComponentValue = targProp.objectReferenceValue as Component;
}
}
break;
case VariantType.Object:
{
var obj = variant.ObjectValue;
if (ComponentUtil.IsAcceptableComponentType(_forcedObjectType))
{
if (obj is GameObject || obj is Component)
{
_selectComponentDrawer.AllowNonComponents = false;
_selectComponentDrawer.RestrictionType = _forcedObjectType;
_selectComponentDrawer.ShowXButton = true;
var targProp = property.FindPropertyRelative("_unityObjectReference");
EditorGUI.BeginChangeCheck();
_selectComponentDrawer.OnGUI(r1, targProp);
if (EditorGUI.EndChangeCheck())
{
variant.ObjectValue = targProp.objectReferenceValue as Component;
}
}
else
{
EditorGUI.BeginChangeCheck();
obj = EditorGUI.ObjectField(r1, obj, typeof(UnityEngine.Object), true);
if (EditorGUI.EndChangeCheck())
{
if (obj == null)
{
variant.ObjectValue = null;
}
else if (TypeUtil.IsType(obj.GetType(), _forcedObjectType))
{
variant.ObjectValue = obj;
}
else
{
var go = GameObjectUtil.GetGameObjectFromSource(obj);
if (go != null)
{
variant.ObjectValue = go.GetComponent(_forcedObjectType);
}
else
{
variant.ObjectValue = null;
}
}
}
}
}
else
{
variant.ObjectValue = EditorGUI.ObjectField(r1, obj, _forcedObjectType, true);
}
}
break;
case VariantType.LayerMask:
{
variant.LayerMaskValue = SPEditorGUI.LayerMaskField(r1, GUIContent.none, (int)variant.LayerMaskValue);
}
break;
case VariantType.Rect:
{
variant.RectValue = EditorGUI.RectField(r1, variant.RectValue);
}
break;
}
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
if (!property.isArray)
{
EditorGUI.PropertyField(position, property, label, false);
return;
}
if (property.arraySize == 0)
{
property.arraySize = 1;
}
if (property.arraySize == 1)
{
var elementHeight = (_internalDrawer != null) ? _internalDrawer.GetPropertyHeight(property.GetArrayElementAtIndex(0), label) : EditorGUIUtility.singleLineHeight;
var propArea = new Rect(position.xMin, position.yMin, Mathf.Max(0f, position.width - BTN_WIDTH), elementHeight);
var btnArea = new Rect(propArea.xMax, position.yMin, Mathf.Min(BTN_WIDTH, position.width), EditorGUIUtility.singleLineHeight);
if (_internalDrawer != null)
{
_internalDrawer.OnGUI(propArea, property.GetArrayElementAtIndex(0), label);
}
else
{
SPEditorGUI.DefaultPropertyField(propArea, property.GetArrayElementAtIndex(0), label);
}
if (GUI.Button(btnArea, _moreBtnLabel))
{
property.arraySize = 2;
}
}
else
{
var elementArea = new Rect(position.xMin, position.yMin, position.width, EditorGUIUtility.singleLineHeight);
//draw header
var leftOverArea = EditorGUI.PrefixLabel(elementArea, label ?? GUIContent.none);
var sizeArea = new Rect(Mathf.Max(leftOverArea.xMin, leftOverArea.xMax - BTN_WIDTH - SIZE_WIDTH),
leftOverArea.yMin,
Mathf.Min(SIZE_WIDTH, Mathf.Max(0f, leftOverArea.width - BTN_WIDTH)), EditorGUIUtility.singleLineHeight);
var btnArea = new Rect(sizeArea.xMax, position.yMin, Mathf.Min(BTN_WIDTH, position.width), EditorGUIUtility.singleLineHeight);
property.arraySize = Mathf.Max(EditorGUI.IntField(sizeArea, property.arraySize), 1);
if (GUI.Button(btnArea, _oneBtnLabel))
{
property.arraySize = 1;
}
EditorGUI.indentLevel++;
for (int i = 0; i < property.arraySize; i++)
{
var lbl = EditorHelper.TempContent("Element " + i.ToString());
var elementHeight = (_internalDrawer != null) ? _internalDrawer.GetPropertyHeight(property.GetArrayElementAtIndex(i), lbl) : EditorGUIUtility.singleLineHeight;
elementArea = new Rect(position.xMin, elementArea.yMax, position.width, elementHeight);
if (_internalDrawer != null)
{
_internalDrawer.OnGUI(elementArea, property.GetArrayElementAtIndex(i), lbl);
}
else
{
SPEditorGUI.DefaultPropertyField(elementArea, property.GetArrayElementAtIndex(i), lbl);
}
}
EditorGUI.indentLevel--;
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
var r0 = new Rect(position.xMin, position.yMin, position.width / 2f, position.height);
var r1 = new Rect(r0.xMax, position.yMin, position.width - r0.width, position.height);
var propName = property.FindPropertyRelative(PROP_NAME);
var propValue = property.FindPropertyRelative(PROP_VALUE);
var propRef = property.FindPropertyRelative(PROP_REF);
int index = System.Array.IndexOf(_knownPlayerSettingPropNames, propName.stringValue);
EditorGUI.BeginChangeCheck();
index = EditorGUI.Popup(r0, GUIContent.none, index, _knownPlayerSettingPropNamesPretty);
if (EditorGUI.EndChangeCheck())
{
if (index >= 0 && index < _knownPlayerSettingPropNames.Length)
{
propName.stringValue = _knownPlayerSettingPropNames[index];
}
else
{
propName.stringValue = string.Empty;
}
propValue.stringValue = string.Empty;
propRef.objectReferenceValue = null;
}
if (index < 0 || index >= _knownPlayerSettings.Length)
{
return;
}
var info = _knownPlayerSettings[index];
if (info.PropertyType.IsEnum)
{
int ei = ConvertUtil.ToInt(propValue.stringValue);
propValue.stringValue = ConvertUtil.ToInt(EditorGUI.EnumPopup(r1, ConvertUtil.ToEnumOfType(info.PropertyType, ei))).ToString();
propRef.objectReferenceValue = null;
}
else
{
var etp = VariantReference.GetVariantType(info.PropertyType);
switch (etp)
{
case VariantType.Null:
propValue.stringValue = string.Empty;
propRef.objectReferenceValue = null;
break;
case VariantType.String:
propValue.stringValue = EditorGUI.TextField(r1, propValue.stringValue);
propRef.objectReferenceValue = null;
break;
case VariantType.Boolean:
propValue.stringValue = EditorGUI.Toggle(r1, GUIContent.none, ConvertUtil.ToBool(propValue.stringValue)).ToString();
propRef.objectReferenceValue = null;
break;
case VariantType.Integer:
propValue.stringValue = EditorGUI.IntField(r1, GUIContent.none, ConvertUtil.ToInt(propValue.stringValue)).ToString();
propRef.objectReferenceValue = null;
break;
case VariantType.Float:
propValue.stringValue = EditorGUI.FloatField(r1, GUIContent.none, ConvertUtil.ToSingle(propValue.stringValue)).ToString();
propRef.objectReferenceValue = null;
break;
case VariantType.Double:
propValue.stringValue = EditorGUI.DoubleField(r1, GUIContent.none, ConvertUtil.ToDouble(propValue.stringValue)).ToString();
propRef.objectReferenceValue = null;
break;
case VariantType.Vector2:
propValue.stringValue = VectorUtil.Stringify(EditorGUI.Vector2Field(r1, GUIContent.none, ConvertUtil.ToVector2(propValue.stringValue)));
propRef.objectReferenceValue = null;
break;
case VariantType.Vector3:
propValue.stringValue = VectorUtil.Stringify(EditorGUI.Vector3Field(r1, GUIContent.none, ConvertUtil.ToVector3(propValue.stringValue)));
propRef.objectReferenceValue = null;
break;
case VariantType.Vector4:
propValue.stringValue = VectorUtil.Stringify(EditorGUI.Vector4Field(r1, (string)null, ConvertUtil.ToVector4(propValue.stringValue)));
propRef.objectReferenceValue = null;
break;
case VariantType.Quaternion:
propValue.stringValue = QuaternionUtil.Stringify(SPEditorGUI.QuaternionField(r1, GUIContent.none, ConvertUtil.ToQuaternion(propValue.stringValue)));
propRef.objectReferenceValue = null;
break;
case VariantType.Color:
propValue.stringValue = ConvertUtil.ToInt(EditorGUI.ColorField(r1, ConvertUtil.ToColor(propValue.stringValue))).ToString();
propRef.objectReferenceValue = null;
break;
case VariantType.DateTime:
//TODO - should never actually occur
propValue.stringValue = string.Empty;
propRef.objectReferenceValue = null;
break;
case VariantType.GameObject:
case VariantType.Component:
case VariantType.Object:
propValue.stringValue = string.Empty;
propRef.objectReferenceValue = EditorGUI.ObjectField(r1, GUIContent.none, propValue.objectReferenceValue, info.PropertyType, false);
break;
case VariantType.LayerMask:
propValue.stringValue = SPEditorGUI.LayerMaskField(r1, GUIContent.none, ConvertUtil.ToInt(propValue.stringValue)).ToString();
propRef.objectReferenceValue = null;
break;
case VariantType.Rect:
//TODO - should never actually occur
propValue.stringValue = string.Empty;
propRef.objectReferenceValue = null;
break;
case VariantType.Numeric:
break;
}
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
EditorGUI.BeginProperty(position, label, property);
var baseType = typeof(object);
bool allowAbstractTypes = false;
bool allowInterfaces = false;
System.Type defaultType = null;
System.Type[] excludedTypes = null;
TypeDropDownListingStyle style = TypeDropDownListingStyle.Namespace;
System.Predicate <System.Type> searchPredicate = null;
if (_isManuallyConfigured)
{
baseType = _inheritsFromType ?? typeof(object);
allowAbstractTypes = _allowAbstractTypes;
allowInterfaces = _allowInterfaces;
defaultType = _defaultType;
excludedTypes = _excludedTypes;
style = _dropDownStyle;
searchPredicate = _searchPredicate;
}
else if (this.fieldInfo != null)
{
var attrib = this.fieldInfo.GetCustomAttributes(typeof(TypeReference.ConfigAttribute), true).FirstOrDefault() as TypeReference.ConfigAttribute;
if (attrib != null)
{
baseType = attrib.inheritsFromType;
allowAbstractTypes = attrib.allowAbstractClasses;
allowInterfaces = attrib.allowInterfaces;
defaultType = attrib.defaultType;
excludedTypes = attrib.excludedTypes;
style = attrib.dropDownStyle;
searchPredicate = null;
}
}
//var tpref = EditorHelper.GetTargetObjectOfProperty(property) as TypeReference;
//if(tpref == null)
//{
// tpref = new TypeReference();
// EditorHelper.SetTargetObjectOfProperty(property, tpref);
// property.serializedObject.ApplyModifiedProperties();
//}
//EditorGUI.BeginChangeCheck();
//tpref.Type = SPEditorGUI.TypeDropDown(position, label, baseType, tpref.Type, allowAbstractTypes, allowInterfaces, defaultType, excludedTypes, style);
//if (EditorGUI.EndChangeCheck())
// property.serializedObject.Update();
var tp = GetTypeFromTypeReference(property);
EditorGUI.BeginChangeCheck();
tp = SPEditorGUI.TypeDropDown(position, label, baseType, tp, allowAbstractTypes, allowInterfaces, defaultType, excludedTypes, style, searchPredicate);
if (EditorGUI.EndChangeCheck())
{
SetTypeToTypeReference(property, tp);
}
EditorGUI.EndProperty();
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
//EditorGUI.BeginProperty(position, label, property);
//if(property.isExpanded)
//{
// var r1 = new Rect(position.xMin, position.yMin, position.width, EditorGUIUtility.singleLineHeight);
// var r2 = new Rect(position.xMin, r1.yMax, position.width, EditorGUIUtility.singleLineHeight);
// var r3 = new Rect(position.xMin, r2.yMax, position.width, EditorGUIUtility.singleLineHeight);
// property.isExpanded = EditorGUI.Foldout(r1, property.isExpanded, GUIContent.none);
// SPEditorGUI.DefaultPropertyField(r1, property.FindPropertyRelative(PROP_WEIGHT), label);
// EditorGUI.indentLevel++;
// SPEditorGUI.DefaultPropertyField(r2, property.FindPropertyRelative(PROP_DIMINISHRATE), EditorHelper.TempContent("Diminish Rate"));
// SPEditorGUI.DefaultPropertyField(r3, property.FindPropertyRelative(PROP_DIMINISHPERIOD), EditorHelper.TempContent("Diminish Period Duration"));
// EditorGUI.indentLevel--;
//}
//else
//{
// property.isExpanded = EditorGUI.Foldout(position, property.isExpanded, GUIContent.none);
// SPEditorGUI.DefaultPropertyField(position, property.FindPropertyRelative(PROP_WEIGHT), label);
//}
//EditorGUI.EndProperty();
if (!this.DrawFoldout || property.isExpanded)
{
const float LINE2_MARGIN = 20f;
var r1 = new Rect(position.xMin, position.yMin, position.width, EditorGUIUtility.singleLineHeight);
var r2 = new Rect(position.xMin + LINE2_MARGIN, r1.yMax, Mathf.Max(position.width - LINE2_MARGIN, 0f), EditorGUIUtility.singleLineHeight);
if (this.DrawFoldout)
{
property.isExpanded = EditorGUI.Foldout(r1, property.isExpanded, GUIContent.none);
}
var weightProp = property.FindPropertyRelative(PROP_WEIGHT);
_line1[0] = weightProp.floatValue;
EditorGUI.BeginChangeCheck();
SPEditorGUI.MultiFloatField(r1, label, _line1Labels, _line1, 50f);
if (EditorGUI.EndChangeCheck())
{
weightProp.floatValue = _line1[0];
}
var maxCountProp = property.FindPropertyRelative(PROP_MAXCOUNT);
var rateProp = property.FindPropertyRelative(PROP_DIMINISHRATE);
var periodProp = property.FindPropertyRelative(PROP_DIMINISHPERIOD);
_line2[0] = maxCountProp.floatValue;
_line2[1] = rateProp.floatValue;
_line2[2] = periodProp.floatValue;
EditorGUI.BeginChangeCheck();
SPEditorGUI.MultiFloatField(r2, _line2Labels, _line2, 80f);
if (EditorGUI.EndChangeCheck())
{
maxCountProp.floatValue = DiscreteFloatPropertyDrawer.NormalizeValue(maxCountProp.floatValue, _line2[0]);
rateProp.floatValue = _line2[1];
periodProp.floatValue = _line2[2];
}
}
else
{
if (this.DrawFoldout)
{
property.isExpanded = EditorGUI.Foldout(position, property.isExpanded, GUIContent.none);
}
var weightProp = property.FindPropertyRelative(PROP_WEIGHT);
_line1[0] = weightProp.floatValue;
SPEditorGUI.MultiFloatField(position, label, _line1Labels, _line1, 50f);
}
}
private void _dataList_DrawElement(Rect area, int index, bool isActive, bool isFocused)
{
Rect position;
var el = _dataList.serializedProperty.GetArrayElementAtIndex(index);
position = CalcNextRect(ref area);
SPEditorGUI.PropertyField(position, el.FindPropertyRelative(PROP_DATA_MODE));
//TODO - member
position = CalcNextRect(ref area);
var memberProp = el.FindPropertyRelative(PROP_DATA_MEMBER);
System.Reflection.MemberInfo selectedMember;
memberProp.stringValue = SPEditorGUI.ReflectedPropertyField(position,
EditorHelper.TempContent("Property", "The property on the target to set."),
_targetProp.objectReferenceValue,
memberProp.stringValue,
out selectedMember);
position = CalcNextRect(ref area);
SPEditorGUI.PropertyField(position, el.FindPropertyRelative(PROP_DATA_EASE));
position = CalcNextRect(ref area);
SPEditorGUI.PropertyField(position, el.FindPropertyRelative(PROP_DATA_DUR));
if (selectedMember != null)
{
var propType = com.spacepuppy.Dynamic.DynamicUtil.GetParameters(selectedMember).FirstOrDefault();
switch (el.FindPropertyRelative(PROP_DATA_MODE).GetEnumValue <TweenHash.AnimMode>())
{
case TweenHash.AnimMode.To:
{
position = CalcNextRect(ref area);
this.DrawVariant(position, EditorHelper.TempContent("To Value"), propType, el.FindPropertyRelative(PROP_DATA_VALUES));
position = CalcNextRect(ref area);
}
break;
case TweenHash.AnimMode.From:
{
position = CalcNextRect(ref area);
this.DrawVariant(position, EditorHelper.TempContent("From Value"), propType, el.FindPropertyRelative(PROP_DATA_VALUES));
}
break;
case TweenHash.AnimMode.By:
{
position = CalcNextRect(ref area);
this.DrawVariant(position, EditorHelper.TempContent("By Value"), propType, el.FindPropertyRelative(PROP_DATA_VALUES));
}
break;
case TweenHash.AnimMode.FromTo:
{
position = CalcNextRect(ref area);
this.DrawVariant(position, EditorHelper.TempContent("Start Value"), propType, el.FindPropertyRelative(PROP_DATA_VALUES));
position = CalcNextRect(ref area);
this.DrawVariant(position, EditorHelper.TempContent("End Value"), propType, el.FindPropertyRelative(PROP_DATA_VALUEE));
}
break;
case TweenHash.AnimMode.RedirectTo:
{
position = CalcNextRect(ref area);
this.DrawVariant(position, EditorHelper.TempContent("Start Value"), propType, el.FindPropertyRelative(PROP_DATA_VALUES));
position = CalcNextRect(ref area);
this.DrawVariant(position, EditorHelper.TempContent("End Value"), propType, el.FindPropertyRelative(PROP_DATA_VALUEE));
}
break;
}
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
this.Init(property);
EditorGUI.BeginProperty(position, label, property);
//################################
//FIRST LINE
var rect = new Rect(position.xMin, position.yMin, position.width, EditorGUIUtility.singleLineHeight);
var configProp = property.FindPropertyRelative(PROP_CONFIGURED);
var targetProp = property.FindPropertyRelative(PROP_TARGET);
//var r0 = new Rect(rect.xMin, rect.yMin, EditorGUIUtility.labelWidth, rect.height);
//rect = new Rect(r0.xMax, rect.yMin, rect.width - r0.width, rect.height);
//property.isExpanded = EditorGUI.Foldout(r0, property.isExpanded, label);
property.isExpanded = SPEditorGUI.PrefixFoldoutLabel(ref rect, property.isExpanded, label);
var r0 = new Rect(rect.xMin, rect.yMin, Mathf.Min(rect.width * 0.25f, 50f), rect.height);
var e = (configProp.boolValue) ? TargetSource.Config : TargetSource.Arg;
EditorGUI.BeginChangeCheck();
e = (TargetSource)EditorGUI.EnumPopup(r0, e);
if (EditorGUI.EndChangeCheck())
{
UpdateTargetFromSource(targetProp, e, (_configAttrib != null) ? _configAttrib.TargetType : null);
configProp.boolValue = (e != TargetSource.Arg);
}
else if (e == TargetSource.Config && !_defaultSet && targetProp.objectReferenceValue == null)
{
UpdateTargetFromSource(targetProp, e, (_configAttrib != null) ? _configAttrib.TargetType : null);
_defaultSet = true;
}
else
{
_defaultSet = true;
}
var r1 = new Rect(rect.xMin + r0.width, rect.yMin, rect.width - r0.width, rect.height);
if (!configProp.boolValue)
{
EditorGUI.LabelField(r1, "Target determined by activating trigger.");
targetProp.objectReferenceValue = null;
}
else
{
_objectDrawer.RestrictionType = (_configAttrib != null) ? _configAttrib.TargetType : null;
_objectDrawer.OnGUI(r1, targetProp, GUIContent.none);
}
//################################
//SECOND LINE
if (property.isExpanded)
{
var indent = EditorGUIUtility.labelWidth * 0.5f;
rect = new Rect(position.xMin + indent, position.yMin + EditorGUIUtility.singleLineHeight, Mathf.Max(0f, position.width - indent), EditorGUIUtility.singleLineHeight);
var w0 = Mathf.Min(rect.width * 0.3f, 120f);
var w1 = Mathf.Min(rect.width * 0.3f, 80f);
var w2 = rect.width - w0 - w1;
r0 = new Rect(rect.xMin, rect.yMin, w0, rect.height);
r1 = new Rect(r0.xMax, rect.yMin, w1, rect.height);
var r2 = new Rect(r1.xMax, rect.yMin, w2, rect.height);
var findProp = property.FindPropertyRelative(PROP_FIND);
var resolveProp = property.FindPropertyRelative(PROP_RESOLVEBY);
var queryProp = property.FindPropertyRelative(PROP_QUERY);
var e0 = findProp.GetEnumValue <TriggerableTargetObject.FindCommand>();
EditorGUI.BeginChangeCheck();
e0 = (TriggerableTargetObject.FindCommand)EditorGUI.EnumPopup(r0, e0);
if (EditorGUI.EndChangeCheck())
{
findProp.SetEnumValue(e0);
}
var e1 = resolveProp.GetEnumValue <TriggerableTargetObject.ResolveByCommand>();
EditorGUI.BeginChangeCheck();
e1 = (TriggerableTargetObject.ResolveByCommand)EditorGUI.EnumPopup(r1, e1);
if (EditorGUI.EndChangeCheck())
{
resolveProp.SetEnumValue(e1);
}
switch (e1)
{
case TriggerableTargetObject.ResolveByCommand.Nothing:
{
GUI.enabled = false;
EditorGUI.TextField(r2, string.Empty);
queryProp.stringValue = string.Empty;
GUI.enabled = true;
}
break;
case TriggerableTargetObject.ResolveByCommand.WithTag:
{
queryProp.stringValue = EditorGUI.TagField(r2, queryProp.stringValue);
}
break;
case TriggerableTargetObject.ResolveByCommand.WithName:
{
queryProp.stringValue = EditorGUI.TextField(r2, queryProp.stringValue);
}
break;
}
}
EditorGUI.EndProperty();
}
public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
{
var signalSourceProp = property.FindPropertyRelative("_signalSource");
return(SPEditorGUI.GetPropertyHeight(signalSourceProp, label, false));
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
if (EditorHelper.AssertMultiObjectEditingNotSupported(position, property, label))
{
return;
}
this.Init(property, label, true);
_currentLabel = label;
if (this.fieldInfo.DeclaringType == typeof(SPAnimationController))
{
_currentLabel.text = "Animation States";
}
property.isExpanded = SPEditorGUI.PrefixFoldoutLabel(position, property.isExpanded, GUIContent.none);
if (!property.isExpanded)
{
//here we emulate the ReorderableList header
//ReorderableListHelper.DrawRetractedHeader(EditorGUI.IndentedRect(position), label);
ReorderableListHelper.DrawRetractedHeader(position, label);
}
else
{
//var cache = SPGUI.DisableIfPlaying();
_animList.displayAdd = !Application.isPlaying;
_animList.displayRemove = !Application.isPlaying;
_animList.draggable = !Application.isPlaying;
EditorGUI.BeginChangeCheck();
//_animList.DoList(EditorGUI.IndentedRect(position));
_animList.DoList(position);
if (EditorGUI.EndChangeCheck())
{
property.serializedObject.ApplyModifiedProperties();
}
if (!_hideDetailRegion && _animList.index >= 0)
{
try
{
var detailRect = new Rect(position.xMin, position.yMin + _animList.GetHeight(), position.width, this.GetDetailHeight());
var stateProp = _animList.serializedProperty.GetArrayElementAtIndex(_animList.index);
var nameProp = stateProp.FindPropertyRelative("_name");
GUI.BeginGroup(detailRect, nameProp.stringValue, GUI.skin.box);
GUI.EndGroup();
//draw basic details
var buffer = EditorGUIUtility.singleLineHeight + 2f;
detailRect = new Rect(detailRect.xMin, detailRect.yMin + buffer, detailRect.width, detailRect.height - buffer);
_clipDrawer.DrawDetails(detailRect, stateProp);
}
catch
{
//failed to draw details because poorly selected nonsense
}
}
//cache.Reset();
}
}
private void DrawAdvanced_TriggerSelected(Rect area, SerializedProperty property)
{
/*
* //Draw Target
* var targRect = new Rect(area.xMin, area.yMin, area.width, EditorGUIUtility.singleLineHeight);
* var targProp = property.FindPropertyRelative(TriggerTargetPropertyDrawer.PROP_TRIGGERABLETARG);
* var targLabel = EditorHelper.TempContent("Triggerable Target");
* var targGo = GameObjectUtil.GetGameObjectFromSource(targProp.objectReferenceValue);
* var newTargGo = EditorGUI.ObjectField(targRect, targLabel, targGo, typeof(GameObject), true) as GameObject;
* if (newTargGo != targGo)
* {
* targGo = newTargGo;
* targProp.objectReferenceValue = (targGo != null) ? targGo.GetComponent<ITriggerableMechanism>() as Component : null;
* }
*
* var targCompPopupRect = new Rect(area.xMin, targRect.yMax, area.width, EditorGUIUtility.singleLineHeight);
* if (targProp.objectReferenceValue != null)
* {
* var selectedType = targProp.objectReferenceValue.GetType();
* var availableMechanismTypes = (from c in targGo.GetComponents<ITriggerableMechanism>() select c.GetType()).ToArray();
* var availableMechanismTypeNames = availableMechanismTypes.Select((tp) => tp.Name).ToArray();
*
* var index = System.Array.IndexOf(availableMechanismTypes, selectedType);
* EditorGUI.BeginChangeCheck();
* index = EditorGUI.Popup(targCompPopupRect, "Target Component", index, availableMechanismTypeNames);
* if (EditorGUI.EndChangeCheck())
* {
* targProp.objectReferenceValue = (index >= 0) ? targGo.GetComponent(availableMechanismTypes[index]) : null;
* }
* }
* else
* {
* EditorGUI.LabelField(targCompPopupRect, "Target Component", "(First Select a Target)");
* }
*
* //Draw Triggerable Arg
* var argRect = new Rect(area.xMin, targCompPopupRect.yMax, area.width - ARG_BTN_WIDTH, EditorGUIUtility.singleLineHeight);
* var btnRect = new Rect(argRect.xMax, argRect.yMin, ARG_BTN_WIDTH, EditorGUIUtility.singleLineHeight);
* var argArrayProp = property.FindPropertyRelative(TriggerTargetPropertyDrawer.PROP_TRIGGERABLEARGS);
* if (argArrayProp.arraySize == 0)
* {
* EditorGUI.LabelField(argRect, _defaultArgLabel, _undefinedArgLabel);
* if (GUI.Button(btnRect, _argBtnLabel))
* {
* argArrayProp.arraySize = 1;
* argArrayProp.serializedObject.ApplyModifiedProperties();
* }
* }
* else
* {
* if (argArrayProp.arraySize > 1) argArrayProp.arraySize = 1;
* var argProp = argArrayProp.GetArrayElementAtIndex(0);
* //EditorGUI.PropertyField(argRect, argProp, _defaultArgLabel);
* _variantDrawer.RestrictVariantType = false;
* _variantDrawer.ForcedObjectType = null;
* _variantDrawer.OnGUI(argRect, argProp, _defaultArgLabel);
*
* if (GUI.Button(btnRect, _argBtnLabel))
* {
* argArrayProp.arraySize = 0;
* argArrayProp.serializedObject.ApplyModifiedProperties();
* }
* }
*/
var targRect = new Rect(area.xMin, area.yMin, area.width, EditorGUIUtility.singleLineHeight);
var targProp = property.FindPropertyRelative(EventTriggerTargetPropertyDrawer.PROP_TRIGGERABLETARG);
targRect = EditorGUI.PrefixLabel(targRect, EditorHelper.TempContent("Triggerable Target"));
//validate
if (!GameObjectUtil.IsGameObjectSource(targProp.objectReferenceValue) && !(targProp.objectReferenceValue is ITriggerable))
{
targProp.objectReferenceValue = null;
}
//draw obj field
if (targProp.objectReferenceValue != null)
{
if (SPEditorGUI.XButton(ref targRect, "Clear Selected Object", true))
{
targProp.objectReferenceValue = null;
goto DrawTriggerableArg;
}
var targObj = targProp.objectReferenceValue;
var availableMechanisms = ObjUtil.GetAllFromSource <ITriggerable>(targObj);
var availableMechanismTypeNames = availableMechanisms.Select((o) => EditorHelper.TempContent(o.GetType().Name)).ToArray();
var index = System.Array.IndexOf(availableMechanisms, targObj);
EditorGUI.BeginChangeCheck();
index = EditorGUI.Popup(targRect, GUIContent.none, index, availableMechanismTypeNames);
if (EditorGUI.EndChangeCheck())
{
targObj = (index >= 0) ? availableMechanisms[index] as UnityEngine.Object : null;
targProp.objectReferenceValue = targObj;
}
}
else
{
EditorGUI.BeginChangeCheck();
var targObj = TargetObjectField(targRect, GUIContent.none, targProp.objectReferenceValue);
if (EditorGUI.EndChangeCheck())
{
targObj = ObjUtil.GetAsFromSource <ITriggerable>(targObj) as UnityEngine.Object;
targProp.objectReferenceValue = targObj;
}
}
//Draw Triggerable Arg
DrawTriggerableArg:
var argRect = new Rect(area.xMin, targRect.yMax, area.width - ARG_BTN_WIDTH, EditorGUIUtility.singleLineHeight);
var btnRect = new Rect(argRect.xMax, argRect.yMin, ARG_BTN_WIDTH, EditorGUIUtility.singleLineHeight);
var argArrayProp = property.FindPropertyRelative(EventTriggerTargetPropertyDrawer.PROP_TRIGGERABLEARGS);
if (argArrayProp.arraySize == 0)
{
EditorGUI.LabelField(argRect, _defaultArgLabel, _undefinedArgLabel);
if (GUI.Button(btnRect, _argBtnLabel))
{
argArrayProp.arraySize = 1;
argArrayProp.serializedObject.ApplyModifiedProperties();
}
}
else
{
if (argArrayProp.arraySize > 1)
{
argArrayProp.arraySize = 1;
}
var argProp = argArrayProp.GetArrayElementAtIndex(0);
//EditorGUI.PropertyField(argRect, argProp, _defaultArgLabel);
_variantDrawer.RestrictVariantType = false;
_variantDrawer.ForcedObjectType = null;
_variantDrawer.OnGUI(argRect, argProp, _defaultArgLabel);
if (GUI.Button(btnRect, _argBtnLabel))
{
argArrayProp.arraySize = 0;
argArrayProp.serializedObject.ApplyModifiedProperties();
}
}
}
private void DrawVector3(Rect position, SerializedProperty property, GUIContent label)
{
position = EditorGUI.PrefixLabel(position, label);
float btnw = Mathf.Min(position.width, BTN_WIDTH);
var rbtn = new Rect(position.xMax - btnw, position.yMin, btnw, EditorGUIUtility.singleLineHeight);
var v = property.vector3Value;
if (v == Vector3.zero)
{
v = Vector3.forward;
property.vector3Value = Vector3.forward;
}
Vector3Directions i = Vector3Directions.Configure;
if (v == Vector3.up)
{
i = Vector3Directions.Up;
}
else if (v == Vector3.down)
{
i = Vector3Directions.Down;
}
else if (v == Vector3.right)
{
i = Vector3Directions.Right;
}
else if (v == Vector3.left)
{
i = Vector3Directions.Left;
}
else if (v == Vector3.forward)
{
i = Vector3Directions.Forward;
}
else if (v == Vector3.back)
{
i = Vector3Directions.Backward;
}
else
{
i = Vector3Directions.Configure;
}
EditorGUI.BeginChangeCheck();
i = (Vector3Directions)EditorGUI.EnumPopup(rbtn, i);
if (EditorGUI.EndChangeCheck())
{
switch (i)
{
case Vector3Directions.Up:
property.vector3Value = Vector3.up;
break;
case Vector3Directions.Down:
property.vector3Value = Vector3.down;
break;
case Vector3Directions.Right:
property.vector3Value = Vector3.right;
break;
case Vector3Directions.Left:
property.vector3Value = Vector3.left;
break;
case Vector3Directions.Forward:
property.vector3Value = Vector3.forward;
break;
case Vector3Directions.Backward:
property.vector3Value = Vector3.back;
break;
}
}
if (i < Vector3Directions.Configure)
{
float w = (position.width - btnw) / 3f;
var r1 = new Rect(position.xMin, position.yMin, w, EditorGUIUtility.singleLineHeight);
var r2 = new Rect(r1.xMax, position.yMin, w, EditorGUIUtility.singleLineHeight);
var r3 = new Rect(r2.xMax, position.yMin, w, EditorGUIUtility.singleLineHeight);
EditorGUI.LabelField(r1, "X: " + v.x.ToString("0.#######"));
EditorGUI.LabelField(r2, "Y: " + v.y.ToString("0.#######"));
EditorGUI.LabelField(r3, "Z: " + v.z.ToString("0.#######"));
}
else
{
//TODO - need way to make this work effectively
var r = new Rect(position.xMin, position.yMin, position.width - btnw, EditorGUIUtility.singleLineHeight);
EditorGUI.BeginChangeCheck();
v = SPEditorGUI.DelayedVector3Field(r, GUIContent.none, v);
if (EditorGUI.EndChangeCheck())
{
property.vector3Value = v.normalized;
}
}
}
public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
{
if (property.serializedObject.targetObject is i_PlayRandomAnimation)
{
this.DrawFlat = true;
var controller = property.serializedObject.FindProperty(i_PlayRandomAnimationInspector.PROP_TARGETANIMATOR).FindPropertyRelative(TriggerableTargetObjectPropertyDrawer.PROP_TARGET).objectReferenceValue;
if (controller is Animation || controller is SPLegacyAnimController)
{
float h = EditorGUIUtility.singleLineHeight * 6f;
var propApplySetting = property.FindPropertyRelative(PROP_APPPLYSETTINGS);
if (propApplySetting.boolValue)
{
var propSettings = property.FindPropertyRelative(PROP_SETTINGS);
propSettings.isExpanded = true;
h += SPEditorGUI.GetPropertyHeight(propSettings, EditorHelper.TempContent(propSettings.displayName), true);
}
else
{
h += EditorGUIUtility.singleLineHeight;
}
return(h);
}
else if (controller is ISPAnimator)
{
return(EditorGUIUtility.singleLineHeight * 2f);
}
else if (controller is ISPAnimationSource)
{
float h = EditorGUIUtility.singleLineHeight * 5f;
if (!this.DrawFlat)
{
h += EditorGUIUtility.singleLineHeight;
}
var propApplySetting = property.FindPropertyRelative(PROP_APPPLYSETTINGS);
if (propApplySetting.boolValue)
{
var propSettings = property.FindPropertyRelative(PROP_SETTINGS);
propSettings.isExpanded = true;
h += SPEditorGUI.GetPropertyHeight(propSettings, EditorHelper.TempContent(propSettings.displayName), true);
}
else
{
h += EditorGUIUtility.singleLineHeight;
}
return(h);
}
else
{
return(EditorGUIUtility.singleLineHeight);
}
}
else
{
if (!this.DrawFlat && !property.isExpanded)
{
return(EditorGUIUtility.singleLineHeight);
}
float h = EditorGUIUtility.singleLineHeight * 6f;
if (!this.DrawFlat)
{
h += EditorGUIUtility.singleLineHeight;
}
var propApplySetting = property.FindPropertyRelative(PROP_APPPLYSETTINGS);
if (propApplySetting.boolValue)
{
var propSettings = property.FindPropertyRelative(PROP_SETTINGS);
propSettings.isExpanded = true;
h += SPEditorGUI.GetPropertyHeight(propSettings, EditorHelper.TempContent(propSettings.displayName), true);
}
else
{
h += EditorGUIUtility.singleLineHeight;
}
return(h);
}
}
private void _maskList_DrawElement(Rect area, int index, bool isActive, bool isFocused)
{
var element = _lst.serializedProperty.GetArrayElementAtIndex(index);
if (element == null)
{
return;
}
//EditorGUI.PropertyField(area, element, GUIContent.none, false);
var attrib = this.attribute as ReorderableArrayAttribute;
GUIContent label = GUIContent.none;
if (attrib != null)
{
if (attrib.ElementLabelFormatString != null)
{
label = EditorHelper.TempContent(string.Format(attrib.ElementLabelFormatString, index));
}
if (attrib.ElementPadding > 0f)
{
area = new Rect(area.xMin + attrib.ElementPadding, area.yMin, Mathf.Max(0f, area.width - attrib.ElementPadding), area.height);
}
}
if (_drawElementAtBottom)
{
var lbl = TempElementLabel(element, index);
SerializedProperty prop = string.IsNullOrEmpty(_childPropertyAsEntry) ? null : element.FindPropertyRelative(_childPropertyAsEntry);
if (prop != null)
{
SPEditorGUI.PropertyField(area, prop, lbl);
}
else
{
EditorGUI.LabelField(area, lbl);
}
}
else
{
if (_internalDrawer != null)
{
_internalDrawer.OnGUI(area, element, label);
}
else if (element.hasChildren && element.objectReferenceValue is MonoBehaviour)
{
//we don't draw this way if it's a built-in type from Unity
var labelArea = new Rect(area.xMin, area.yMin, area.width, EditorGUIUtility.singleLineHeight);
EditorGUI.LabelField(labelArea, label);
var childArea = new Rect(area.xMin, area.yMin + EditorGUIUtility.singleLineHeight + 1f, area.width, area.height - EditorGUIUtility.singleLineHeight);
SPEditorGUI.FlatChildPropertyField(childArea, element);
}
else
{
SPEditorGUI.DefaultPropertyField(area, element, label, false);
}
}
if (GUI.enabled)
{
ReorderableListHelper.DrawDraggableElementDeleteContextMenu(_lst, area, index, isActive, isFocused);
}
}
private void DrawGenerically(Rect position, SerializedProperty property, GUIContent label)
{
if (!this.DrawFlat)
{
var rh = new Rect(position.xMin, position.yMin, position.width, EditorGUIUtility.singleLineHeight);
position = new Rect(position.xMin, rh.yMax, position.width, position.height - rh.height);
property.isExpanded = EditorGUI.Foldout(rh, property.isExpanded, label);
if (!property.isExpanded)
{
return;
}
}
var r0 = new Rect(position.xMin, position.yMin, position.width, EditorGUIUtility.singleLineHeight);
var r1 = new Rect(r0.xMin, r0.yMax, r0.width, EditorGUIUtility.singleLineHeight);
var r2 = new Rect(r1.xMin, r1.yMax, r1.width, EditorGUIUtility.singleLineHeight);
var r3 = new Rect(r2.xMin, r2.yMax, r2.width, position.yMax - r2.yMax - EditorGUIUtility.singleLineHeight * 3f);
var r4 = new Rect(r3.xMin, r3.yMax, r3.width, EditorGUIUtility.singleLineHeight);
var r5 = new Rect(r4.xMin, r4.yMax, r4.width, EditorGUIUtility.singleLineHeight);
var r6 = new Rect(r5.xMin, r5.yMax, r5.width, EditorGUIUtility.singleLineHeight);
SPEditorGUI.PropertyField(r0, property.FindPropertyRelative(PROP_WEIGHT));
var propMode = property.FindPropertyRelative(PROP_MODE);
SPEditorGUI.PropertyField(r1, propMode);
switch (propMode.GetEnumValue <i_PlayAnimation.PlayByMode>())
{
case i_PlayAnimation.PlayByMode.PlayAnim:
{
property.FindPropertyRelative(PROP_ID).stringValue = string.Empty;
var clipProp = property.FindPropertyRelative(PROP_CLIP);
var obj = EditorGUI.ObjectField(r2, EditorHelper.TempContent(clipProp.displayName), clipProp.objectReferenceValue, typeof(UnityEngine.Object), true);
if (obj == null || obj is AnimationClip || obj is IScriptableAnimationClip)
{
clipProp.objectReferenceValue = obj;
}
else if (GameObjectUtil.IsGameObjectSource(obj))
{
clipProp.objectReferenceValue = ObjUtil.GetAsFromSource <IScriptableAnimationClip>(obj) as UnityEngine.Object;
}
}
break;
case i_PlayAnimation.PlayByMode.PlayAnimByID:
{
property.FindPropertyRelative(PROP_CLIP).objectReferenceValue = null;
SPEditorGUI.PropertyField(r2, property.FindPropertyRelative(PROP_ID));
}
break;
case i_PlayAnimation.PlayByMode.PlayAnimFromResource:
{
property.FindPropertyRelative(PROP_CLIP).objectReferenceValue = null;
SPEditorGUI.PropertyField(r2, property.FindPropertyRelative(PROP_ID));
}
break;
}
this.DrawSettings(r3, property);
SPEditorGUI.PropertyField(r4, property.FindPropertyRelative(PROP_QUEUEMODE));
SPEditorGUI.PropertyField(r5, property.FindPropertyRelative(PROP_PLAYMODE));
SPEditorGUI.PropertyField(r6, property.FindPropertyRelative(PROP_CROSSFADEDUR));
}
public void OnGUI(Rect position, SerializedProperty property)
{
//if (property.propertyType != SerializedPropertyType.ObjectReference || !TypeUtil.IsType(_restrictionType, typeof(Component), typeof(IComponent)))
if (property.propertyType != SerializedPropertyType.ObjectReference || (!this.AllowNonComponents && !(TypeUtil.IsType(_restrictionType, typeof(Component)) || _restrictionType.IsInterface)))
{
this.DrawAsMismatchedAttribute(position, property);
return;
}
this.Init();
GameObject targGo;
if (this.ForceOnlySelf)
{
targGo = GameObjectUtil.GetGameObjectFromSource(property.serializedObject.targetObject);
if (targGo == null)
{
this.DrawAsMismatchedAttribute(position, property);
return;
}
if (property.objectReferenceValue == null)
{
property.objectReferenceValue = targGo.GetComponent(_restrictionType);
}
}
targGo = GameObjectUtil.GetGameObjectFromSource(property.objectReferenceValue);
if (property.objectReferenceValue == null)
{
//SPEditorGUI.DefaultPropertyField(position, property, label);
if (!this.ForceOnlySelf)
{
this.DrawObjectRefField(position, property);
}
else
{
EditorGUI.LabelField(position, "Malformed serializable field.");
}
}
else if (this.AllowNonComponents)
{
if (targGo == null)
{
this.DrawObjectRefField(position, property);
}
else
{
this.ChoiceSelector.BeforeGUI(this, property, this.ComponentRestrictionType);
var components = this.ChoiceSelector.GetComponents();
var fullsize = position;
if (components.Length == 0 ||
(this.ShowXButton && SPEditorGUI.XButton(ref position, "Clear Selected Object", this.XButtonOnRightSide)))
{
property.objectReferenceValue = null;
fullsize = this.DrawDotDotButton(fullsize, property);
this.DrawObjectRefField(fullsize, property);
this.ChoiceSelector.GUIComplete(property, -1);
}
else
{
position = this.DrawDotDotButton(position, property);
var names = this.ChoiceSelector.GetPopupEntries();
System.Array.Resize(ref names, names.Length + 1);
names[names.Length - 1] = EditorHelper.TempContent(targGo.name + " (...GameObject)");
int oi = (property.objectReferenceValue is GameObject) ? names.Length - 1 : this.ChoiceSelector.GetPopupIndexOfComponent(property.objectReferenceValue as Component);
int ni = EditorGUI.Popup(position, oi, names);
if (oi != ni)
{
if (ni == names.Length - 1)
{
property.objectReferenceValue = targGo;
}
else
{
property.objectReferenceValue = this.ChoiceSelector.GetComponentAtPopupIndex(ni);
}
//if (ni < components.Length)
// property.objectReferenceValue = this.ChoiceSelector.GetComponentAtPopupIndex(ni);
//else
// property.objectReferenceValue = targGo;
}
this.ChoiceSelector.GUIComplete(property, ni);
}
}
}
else
{
this.ChoiceSelector.BeforeGUI(this, property, this.ComponentRestrictionType);
var components = this.ChoiceSelector.GetComponents();
var fullsize = position;
if (components.Length == 0 ||
(this.ShowXButton && SPEditorGUI.XButton(ref position, "Clear Selected Object", this.XButtonOnRightSide)))
{
property.objectReferenceValue = null;
fullsize = this.DrawDotDotButton(fullsize, property);
this.DrawObjectRefField(fullsize, property);
this.ChoiceSelector.GUIComplete(property, -1);
}
else
{
position = this.DrawDotDotButton(position, property);
var names = this.ChoiceSelector.GetPopupEntries();
int oi = this.ChoiceSelector.GetPopupIndexOfComponent(property.objectReferenceValue as Component);
int ni = EditorGUI.Popup(position, oi, names);
if (oi != ni)
{
property.objectReferenceValue = this.ChoiceSelector.GetComponentAtPopupIndex(ni);
}
this.ChoiceSelector.GUIComplete(property, ni);
}
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
if (!this.ValidateFieldType())
{
EditorGUI.PropertyField(position, property, label);
return;
}
EditorGUI.BeginProperty(position, label, property);
//get base type
var attrib = this.attribute as TypeRestrictionAttribute;
bool isArray = this.fieldInfo.FieldType.IsListType();
var fieldType = (isArray) ? this.fieldInfo.FieldType.GetElementTypeOfListType() : this.fieldInfo.FieldType;
bool fieldIsComponentType = TypeUtil.IsType(fieldType, typeof(Component));
bool objIsComponentType = property.objectReferenceValue is Component;
var inheritsFromType = attrib.InheritsFromType ?? ((fieldIsComponentType) ? typeof(Component) : fieldType);
if (attrib.HideTypeDropDown || !objIsComponentType)
{
//draw object field
if (fieldIsComponentType)
{
var fieldCompType = (TypeUtil.IsType(fieldType, typeof(Component))) ? fieldType : typeof(Component);
var comp = SPEditorGUI.ComponentField(position, label, property.objectReferenceValue as Component, inheritsFromType, true, fieldCompType);
if (comp == null)
{
property.objectReferenceValue = null;
}
else
{
property.objectReferenceValue = ObjUtil.GetAsFromSource(inheritsFromType, comp) as UnityEngine.Object;
}
//else if (TypeUtil.IsType(comp.GetType(), inheritsFromType))
// property.objectReferenceValue = comp;
//else
// property.objectReferenceValue = comp.GetComponent(inheritsFromType);
}
else
{
var obj = EditorGUI.ObjectField(position, label, property.objectReferenceValue, fieldType, true);
if (obj == null)
{
property.objectReferenceValue = null;
}
else
{
property.objectReferenceValue = ObjUtil.GetAsFromSource(inheritsFromType, obj) as UnityEngine.Object;
}
}
}
else
{
//draw complex field
if (_selectComponentDrawer == null)
{
_selectComponentDrawer = new SelectableComponentPropertyDrawer();
}
_selectComponentDrawer.RestrictionType = inheritsFromType ?? typeof(Component);
_selectComponentDrawer.ShowXButton = true;
_selectComponentDrawer.OnGUI(position, property, label);
}
EditorGUI.EndProperty();
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
this.Init(property);
EditorGUI.BeginProperty(position, label, property);
//################################
//FIRST LINE
var rect = new Rect(position.xMin, position.yMin, position.width, EditorGUIUtility.singleLineHeight);
rect = EditorGUI.PrefixLabel(rect, label);
var targetProp = property.FindPropertyRelative(PROP_TARGET);
var w0 = Mathf.Min(rect.width * 0.3f, 80f);
var w1 = rect.width - w0;
var r0 = new Rect(rect.xMin, rect.yMin, w0, EditorGUIUtility.singleLineHeight);
var r1 = new Rect(r0.xMax, rect.yMin, w1, EditorGUIUtility.singleLineHeight);
var searchProp = property.FindPropertyRelative(PROP_SEARCHBY);
var queryProp = property.FindPropertyRelative(PROP_QUERY);
var eSearchBy = (SearchByAlt)searchProp.GetEnumValue <SearchBy>();
EditorGUI.BeginChangeCheck();
eSearchBy = (SearchByAlt)EditorGUI.EnumPopup(r0, eSearchBy);
if (EditorGUI.EndChangeCheck())
{
searchProp.SetEnumValue((SearchBy)eSearchBy);
}
switch (eSearchBy)
{
case SearchByAlt.Direct:
{
//SPEditorGUI.PropertyField(r1, targetProp, GUIContent.none);
if (_selectableDrawer == null)
{
_selectableDrawer = new SelectableComponentPropertyDrawer();
}
_selectableDrawer.AllowSceneObjects = true;
_selectableDrawer.RestrictionType = _inheritsFromType;
_selectableDrawer.AllowProxy = _allowProxy;
_selectableDrawer.OnGUI(r1, targetProp, GUIContent.none);
}
break;
case SearchByAlt.Tag:
{
queryProp.stringValue = EditorGUI.TagField(r1, queryProp.stringValue);
targetProp.objectReferenceValue = null;
}
break;
case SearchByAlt.Name:
{
queryProp.stringValue = EditorGUI.TextField(r1, queryProp.stringValue);
targetProp.objectReferenceValue = null;
}
break;
case SearchByAlt.Type:
{
var tp = TypeUtil.FindType(queryProp.stringValue);
if (!TypeUtil.IsType(tp, typeof(UnityEngine.Object)))
{
tp = null;
}
tp = SPEditorGUI.TypeDropDown(r1, GUIContent.none, typeof(UnityEngine.Object), tp);
queryProp.stringValue = (tp != null) ? tp.FullName : null;
targetProp.objectReferenceValue = null;
}
break;
}
EditorGUI.EndProperty();
}
private void _targetList_DrawElement(Rect area, int index, bool isActive, bool isFocused)
{
var element = _targetList.serializedProperty.GetArrayElementAtIndex(index);
var trigProp = element.FindPropertyRelative(TriggerTargetProps.PROP_TRIGGERABLETARG);
var actProp = element.FindPropertyRelative(TriggerTargetProps.PROP_ACTIVATIONTYPE);
//var act = (TriggerActivationType)actProp.enumValueIndex;
var act = actProp.GetEnumValue <TriggerActivationType>();
const float MARGIN = 1.0f;
if (act == TriggerActivationType.TriggerAllOnTarget)
{
//Draw Triggerable - this is the simple case to make a clean designer set up for newbs
var trigRect = new Rect(area.xMin, area.yMin + MARGIN, area.width, EditorGUIUtility.singleLineHeight);
var trigLabel = new GUIContent("Target");
EditorGUI.BeginProperty(trigRect, trigLabel, trigProp);
trigProp.objectReferenceValue = SPEditorGUI.ComponentField(trigRect,
trigLabel,
TriggerTargetPropertyDrawer.ValidateTriggerableTargAsMechanism(trigProp.objectReferenceValue) as Component,
typeof(ITriggerableMechanism),
true);
EditorGUI.EndProperty();
}
else
{
//Draw Triggerable - this forces the user to use the advanced settings, not for newbs
var trigRect = new Rect(area.xMin, area.yMin + MARGIN, area.width, EditorGUIUtility.singleLineHeight);
var trigLabel = new GUIContent("Advanced Target", "A target is not set, see advanced settings section to set a target.");
if (trigProp.objectReferenceValue != null)
{
var go = GameObjectUtil.GetGameObjectFromSource(trigProp.objectReferenceValue);
var trigType = trigProp.objectReferenceValue.GetType();
GUIContent extraLabel;
switch (act)
{
case TriggerActivationType.SendMessage:
extraLabel = new GUIContent("(SendMessage) " + go.name);
break;
case TriggerActivationType.TriggerSelectedTarget:
extraLabel = new GUIContent("(TriggerSelectedTarget) " + go.name + " -> " + trigType.Name);
break;
case TriggerActivationType.CallMethodOnSelectedTarget:
extraLabel = new GUIContent("(CallMethodOnSelectedTarget) " + go.name + " -> " + trigType.Name + "." + element.FindPropertyRelative(TriggerTargetProps.PROP_METHODNAME).stringValue);
break;
default:
extraLabel = GUIContent.none;
break;
}
EditorGUI.LabelField(trigRect, trigLabel, extraLabel);
}
else
{
EditorGUI.LabelField(trigRect, trigLabel, new GUIContent("No Target"), new GUIStyle("Label")
{
alignment = TextAnchor.MiddleCenter
});
}
}
ReorderableListHelper.DrawDraggableElementDeleteContextMenu(_targetList, area, index, isActive, isFocused);
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
if (EditorHelper.AssertMultiObjectEditingNotSupported(position, property, label))
{
return;
}
if (property.isArray)
{
if (this.CustomLabel != null)
{
label = this.CustomLabel;
}
else if (label != null)
{
label = EditorHelper.CloneContent(label);
if (_showTooltipInHeader)
{
label.text = string.Format("{0} [{1:0}] - {2}", label.text, property.arraySize, (string.IsNullOrEmpty(label.tooltip) ? property.tooltip : label.tooltip));
}
else
{
label.text = string.Format("{0} [{1:0}]", label.text, property.arraySize);
}
if (string.IsNullOrEmpty(label.tooltip))
{
label.tooltip = property.tooltip;
}
}
else
{
label = EditorHelper.TempContent(property.displayName, property.tooltip);
}
//const float WIDTH_FOLDOUT = 5f;
var foldoutRect = new Rect(position.xMin, position.yMin, position.width, EditorGUIUtility.singleLineHeight);
position = EditorGUI.IndentedRect(position);
Rect listArea = position;
if (_disallowFoldout)
{
listArea = new Rect(position.xMin, position.yMin, position.width, _lst.GetHeight());
this.StartOnGUI(property, label);
//_lst.DoList(EditorGUI.IndentedRect(position));
_lst.DoList(listArea);
this.EndOnGUI(property, label);
}
else
{
if (property.isExpanded)
{
listArea = new Rect(position.xMin, position.yMin, position.width, _lst.GetHeight());
this.StartOnGUI(property, label);
property.isExpanded = EditorGUI.Foldout(foldoutRect, property.isExpanded, GUIContent.none);
//_lst.DoList(EditorGUI.IndentedRect(position));
_lst.DoList(listArea);
this.EndOnGUI(property, label);
}
else
{
if (_removeBackgroundWhenCollapsed)
{
property.isExpanded = EditorGUI.Foldout(foldoutRect, property.isExpanded, label);
}
else
{
property.isExpanded = EditorGUI.Foldout(foldoutRect, property.isExpanded, GUIContent.none);
//ReorderableListHelper.DrawRetractedHeader(EditorGUI.IndentedRect(position), label);
ReorderableListHelper.DrawRetractedHeader(position, label);
}
}
}
this.DoDragAndDrop(property, listArea);
if (property.isExpanded && _drawElementAtBottom && _lst.index >= 0 && _lst.index < property.arraySize)
{
var pchild = property.GetArrayElementAtIndex(_lst.index);
var label2 = TempElementLabel(pchild, _lst.index); //(string.IsNullOrEmpty(_childPropertyAsLabel)) ? TempElementLabel(_lst.index) : GUIContent.none;
pchild.isExpanded = true;
float h;
if (_internalDrawer != null)
{
h = _internalDrawer.GetPropertyHeight(pchild, label2) + BOTTOM_PAD + TOP_PAD;
}
else if (pchild.hasChildren)
{
h = SPEditorGUI.GetDefaultPropertyHeight(pchild, label, true) + BOTTOM_PAD + TOP_PAD - EditorGUIUtility.singleLineHeight;
}
else
{
h = SPEditorGUI.GetDefaultPropertyHeight(pchild, label2, true) + BOTTOM_PAD + TOP_PAD;
}
var area = new Rect(position.xMin, position.yMax - h, position.width, h);
var drawArea = new Rect(area.xMin, area.yMin + TOP_PAD, area.width - MARGIN, area.height - TOP_PAD);
GUI.BeginGroup(area, label2, GUI.skin.box);
GUI.EndGroup();
EditorGUI.indentLevel++;
if (_internalDrawer != null)
{
_internalDrawer.OnGUI(drawArea, pchild, label2);
}
else if (pchild.hasChildren)
{
SPEditorGUI.FlatChildPropertyField(drawArea, pchild);
}
else
{
SPEditorGUI.DefaultPropertyField(drawArea, pchild, GUIContent.none, false);
}
EditorGUI.indentLevel--;
}
}
else
{
SPEditorGUI.DefaultPropertyField(position, property, label, false);
}
}
private void DrawAdvanced_CallMethodOnSelected(Rect area, SerializedProperty property)
{
//Draw Target
var targRect = new Rect(area.xMin, area.yMin, area.width, EditorGUIUtility.singleLineHeight);
var targProp = property.FindPropertyRelative(TriggerTargetProps.PROP_TRIGGERABLETARG);
var targLabel = new GUIContent("Triggerable Target");
var targGo = GameObjectUtil.GetGameObjectFromSource(targProp.objectReferenceValue);
var newTargGo = EditorGUI.ObjectField(targRect, targLabel, targGo, typeof(GameObject), true) as GameObject;
if (newTargGo != targGo)
{
targGo = newTargGo;
targProp.objectReferenceValue = (targGo != null) ? targGo.transform : null;
}
var targCompPopupRect = new Rect(area.xMin, targRect.yMax, area.width, EditorGUIUtility.singleLineHeight);
if (targGo != null)
{
EditorGUI.BeginChangeCheck();
var selectedComp = SPEditorGUI.SelectComponentFromSourceField(targCompPopupRect, "Target Component", targGo, targProp.objectReferenceValue as Component);
if (EditorGUI.EndChangeCheck())
{
targProp.objectReferenceValue = selectedComp;
}
}
else
{
EditorGUI.LabelField(targCompPopupRect, "Target Component", "(First Select a Target)");
}
//Draw Method Name
var methNameRect = new Rect(area.xMin, targCompPopupRect.yMax, area.width, EditorGUIUtility.singleLineHeight);
System.Reflection.MemberInfo selectedMember = null;
if (targProp.objectReferenceValue != null)
{
var methProp = property.FindPropertyRelative(TriggerTargetProps.PROP_METHODNAME);
//var tp = targProp.objectReferenceValue.GetType();
//var members = GetAvailableMethods(tp).ToArray();
//var members = com.spacepuppy.Dynamic.DynamicUtil.GetEasilySerializedMembers(targProp.objectReferenceValue, System.Reflection.MemberTypes.Method).ToArray();
var members = com.spacepuppy.Dynamic.DynamicUtil.GetEasilySerializedMembers(targProp.objectReferenceValue, System.Reflection.MemberTypes.All, spacepuppy.Dynamic.DynamicMemberAccess.Write).ToArray();
System.Array.Sort(members, (a, b) => string.Compare(a.Name, b.Name, true));
var memberNames = members.Select((m) => m.Name).ToArray();
int index = System.Array.IndexOf(memberNames, methProp.stringValue);
index = EditorGUI.Popup(methNameRect, new GUIContent("Method", "The method/prop on the target to call."), index, (from n in memberNames select new GUIContent(n)).ToArray());
methProp.stringValue = (index >= 0) ? memberNames[index] : null;
selectedMember = (index >= 0) ? members[index] : null;
}
else
{
EditorGUI.Popup(methNameRect, new GUIContent("Method", "The method/prop on the target to call."), -1, new GUIContent[0]);
}
property.serializedObject.ApplyModifiedProperties();
//Draw Triggerable Arg
var parr = (selectedMember != null) ? com.spacepuppy.Dynamic.DynamicUtil.GetDynamicParameterInfo(selectedMember) : null;
if (parr == null || parr.Length == 0)
{
//NO PARAMETERS
_callMethodModeExtraLines = 1;
var argRect = new Rect(area.xMin, methNameRect.yMax, area.width, EditorGUIUtility.singleLineHeight);
var argArrayProp = property.FindPropertyRelative(TriggerTargetProps.PROP_TRIGGERABLEARGS);
if (argArrayProp.arraySize > 0)
{
argArrayProp.arraySize = 0;
argArrayProp.serializedObject.ApplyModifiedProperties();
}
var cache = SPGUI.Disable();
EditorGUI.LabelField(argRect, GUIContent.none, new GUIContent("*Zero Parameter Count*"));
cache.Reset();
}
else
{
//MULTIPLE PARAMETERS - special case, does not support trigger event arg
_callMethodModeExtraLines = parr.Length;
var argArrayProp = property.FindPropertyRelative(TriggerTargetProps.PROP_TRIGGERABLEARGS);
if (argArrayProp.arraySize != parr.Length)
{
argArrayProp.arraySize = parr.Length;
argArrayProp.serializedObject.ApplyModifiedProperties();
}
EditorGUI.indentLevel++;
for (int i = 0; i < parr.Length; i++)
{
var paramType = parr[i].ParameterType;
var argRect = new Rect(area.xMin, methNameRect.yMax + i * EditorGUIUtility.singleLineHeight, area.width, EditorGUIUtility.singleLineHeight);
var argProp = argArrayProp.GetArrayElementAtIndex(i);
if (paramType == typeof(object))
{
//draw the default variant as the method accepts anything
_variantDrawer.RestrictVariantType = false;
_variantDrawer.ForcedObjectType = null;
_variantDrawer.OnGUI(argRect, argProp, EditorHelper.TempContent("Arg " + i.ToString() + ": " + parr[i].ParameterName, "A parameter to be passed to the method if needed."));
}
else
{
var argType = VariantReference.GetVariantType(paramType);
_variantDrawer.RestrictVariantType = true;
_variantDrawer.VariantTypeRestrictedTo = argType;
_variantDrawer.ForcedObjectType = (paramType.IsInterface || TypeUtil.IsType(paramType, typeof(Component))) ? paramType : null;
_variantDrawer.OnGUI(argRect, argProp, EditorHelper.TempContent("Arg " + i.ToString() + ": " + parr[i].ParameterName, "A parameter to be passed to the method if needed."));
}
}
EditorGUI.indentLevel--;
}
}
public void DrawDetails(Rect position, SerializedProperty property)
{
var cache = SPGUI.DisableIfPlaying();
//draw basic details
var yMin = position.yMin;
for (int i = 0; i < _detailProps.Length; i++)
{
//var r = new Rect(position.xMin, yMin + i * EditorGUIUtility.singleLineHeight, position.width, EditorGUIUtility.singleLineHeight);
switch (_detailProps[i])
{
case SPAnimClip.PROP_WRAPMODE:
{
var r = new Rect(position.xMin, position.yMin, position.width, EditorGUIUtility.singleLineHeight);
position = new Rect(position.xMin, r.yMax, position.width, Mathf.Max(position.height - r.height, 0f));
var wrapModeProp = property.FindPropertyRelative(SPAnimClip.PROP_WRAPMODE);
wrapModeProp.SetEnumValue(SPEditorGUI.WrapModeField(r, wrapModeProp.displayName, wrapModeProp.GetEnumValue <WrapMode>(), true));
}
break;
case "ScaledDuration":
{
var r = new Rect(position.xMin, position.yMin, position.width, EditorGUIUtility.singleLineHeight);
position = new Rect(position.xMin, r.yMax, position.width, Mathf.Max(position.height - r.height, 0f));
var label = EditorHelper.TempContent("Scaled Duration", "The duration of the clip with the speed applied. Modifying this alters the 'speed' property.");
var clip = property.FindPropertyRelative(PROP_CLIP).objectReferenceValue as AnimationClip;
if (clip == null)
{
EditorGUI.FloatField(r, label, 0f);
continue;
}
var speedProp = property.FindPropertyRelative(SPAnimClip.PROP_SPEED);
float dur = (speedProp.floatValue == 0f) ? float.PositiveInfinity : Mathf.Abs(clip.length / speedProp.floatValue);
EditorGUI.BeginChangeCheck();
dur = EditorGUI.FloatField(r, label, dur);
if (EditorGUI.EndChangeCheck())
{
speedProp.floatValue = (dur <= 0f) ? 0f : clip.length / dur;
}
}
break;
default:
{
var r = new Rect(position.xMin, position.yMin, position.width, EditorGUIUtility.singleLineHeight);
position = new Rect(position.xMin, r.yMax, position.width, Mathf.Max(position.height - r.height, 0f));
EditorGUI.PropertyField(r, property.FindPropertyRelative(_detailProps[i]));
}
break;
}
}
cache.Reset();
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
if (property.propertyType != SerializedPropertyType.String)
{
SPEditorGUI.DefaultPropertyField(position, property, label);
return;
}
var tr = GameObjectUtil.GetTransformFromSource(property.serializedObject.targetObject);
if (tr == null)
{
SPEditorGUI.DefaultPropertyField(position, property, label);
return;
}
IAIController controller = tr.GetComponent <IAIController>();
while (controller == null && tr.parent != null)
{
tr = tr.parent;
controller = tr.GetComponent <IAIController>();
}
if (controller == null)
{
SPEditorGUI.DefaultPropertyField(position, property, label);
return;
}
var names = (controller.Variables == null) ? new string[] {} : controller.Variables.Names.ToArray();
var guiNames = (from n in names select EditorHelper.TempContent(n)).Append(EditorHelper.TempContent("Custom...")).ToArray();
int index = names.IndexOf(property.stringValue);
if (index < 0)
{
index = names.Length;
}
if (index == names.Length)
{
var fw = position.width - EditorGUIUtility.labelWidth;
var wl = EditorGUIUtility.labelWidth + (fw / 4f);
var wr = position.width - wl - 1f;
var rl = new Rect(position.xMin, position.yMin, wl, EditorGUIUtility.singleLineHeight);
var rr = new Rect(rl.xMax + 1f, rl.yMin, wr, EditorGUIUtility.singleLineHeight);
index = EditorGUI.Popup(rl, label, index, guiNames);
if (index >= 0 && index < names.Length)
{
property.stringValue = names[index];
}
else
{
property.stringValue = EditorGUI.TextField(rr, property.stringValue);
}
}
else
{
index = EditorGUI.Popup(position, label, index, guiNames);
property.stringValue = (index >= 0 && index < names.Length) ? names[index] : null;
}
}