private void OnGUI() { //draw header if (Application.isPlaying) { var cache = SPGUI.Disable(); EditorGUILayout.ObjectField("Current Target: ", _ai, typeof(AITreeController), true); cache.Reset(); } else { var rect = EditorGUILayout.GetControlRect(); Rect r1, r2; const float BTN_WIDTH = 150f; if (rect.width > BTN_WIDTH * 2f) { r1 = new Rect(rect.xMin, rect.yMin, rect.width - BTN_WIDTH, rect.height); r2 = new Rect(r1.xMax, rect.yMin, BTN_WIDTH, rect.height); } else { var w = rect.width / 2f; r1 = new Rect(rect.xMin, rect.yMin, w, rect.height); r2 = new Rect(r1.xMax, rect.yMin, w, rect.height); } var cache = SPGUI.Disable(); EditorGUI.ObjectField(r1, "Current Target: ", _ai, typeof(AITreeController), true); cache.Reset(); if (GUI.Button(r2, "Sync Actions")) { this.SyncActions(); } } //if we're not configured correctly, stop if (_ai == null) { return; } if (_currentTable == null) { this.CleanCurrentState(); } //draw actions _scrollPosition = EditorGUILayout.BeginScrollView(_scrollPosition); try { this.DrawNode(_ai); //this.DrawActionGroup(_ai); } catch (System.Exception ex) { Debug.LogException(ex); } EditorGUILayout.EndScrollView(); }
private void DrawReadOnlyInspector(Singleton.ConfigAttribute attrib) { this.DrawPropertyField(EditorHelper.PROP_SCRIPT); var prop = this.serializedObject.FindProperty("_maintainer._lifeCycle"); if (prop.GetEnumValue <SingletonLifeCycleRule>() != attrib.DefaultLifeCycle) { prop.SetEnumValue(attrib.DefaultLifeCycle); } var cache = SPGUI.Disable(); EditorGUILayout.EnumPopup("Life Cycle", prop.GetEnumValue <SingletonLifeCycleRule>()); cache.Reset(); this.DrawDefaultInspectorExcept(EditorHelper.PROP_SCRIPT, "_maintainer"); }
protected void DrawSPAnimationControllerProps() { if (Application.isPlaying) { var targ = this.target as SPAnimationController; if (targ == null) { return; } EditorGUI.BeginChangeCheck(); var b1 = EditorGUILayout.Toggle("Animate Physics", targ.AnimatePhysics); if (EditorGUI.EndChangeCheck()) { targ.AnimatePhysics = b1; } EditorGUI.BeginChangeCheck(); var ectp = (AnimationCullingType)EditorGUILayout.EnumPopup("Culling Type", targ.CullingType); if (EditorGUI.EndChangeCheck()) { targ.CullingType = ectp; } var cache = SPGUI.Disable(); this.DrawPropertyField(PROP_TIMESUPPLIER); this.DrawPropertyField(PROP_SPEED); this.DrawPropertyField(PROP_MASK); cache.Reset(); this.DrawPropertyField(PROP_STATES); } else { this.DrawPropertyField(PROP_ANIMATEPHYSICS, "Animate Physics", false); this.DrawPropertyField(PROP_ANIMCULLING, "Culling Type", false); this.DrawPropertyField(PROP_TIMESUPPLIER); this.DrawPropertyField(PROP_SPEED); this.DrawPropertyField(PROP_MASK); this.DrawPropertyField(PROP_STATES); } }
protected override void OnSPInspectorGUI() { this.serializedObject.Update(); this.DrawDefaultInspectorExcept("_target", "_memberName", "_value", "_mode"); this.DrawPropertyField("_target"); //uses the SelectableComponent PropertyDrawer var targProp = this.serializedObject.FindProperty("_target"); var memberProp = this.serializedObject.FindProperty("_memberName"); var valueProp = this.serializedObject.FindProperty("_value"); var modeProp = this.serializedObject.FindProperty("_mode"); //SELECT MEMBER System.Reflection.MemberInfo selectedMember; memberProp.stringValue = SPEditorGUILayout.ReflectedRecursingPropertyField(EditorHelper.TempContent("Property", "The property on the target to set."), targProp.objectReferenceValue, memberProp.stringValue, com.spacepuppy.Dynamic.DynamicMemberAccess.ReadWrite, out selectedMember); this.serializedObject.ApplyModifiedProperties(); //MEMBER VALUE TO SET TO if (selectedMember != null) { var propType = com.spacepuppy.Dynamic.DynamicUtil.GetInputType(selectedMember); var emode = modeProp.GetEnumValue <i_SetValue.SetMode>(); if (emode == i_SetValue.SetMode.Toggle) { //EditorGUILayout.LabelField(EditorHelper.TempContent(valueProp.displayName), EditorHelper.TempContent(propType.Name)); var evtp = VariantReference.GetVariantType(propType); var cache = SPGUI.Disable(); EditorGUILayout.EnumPopup(EditorHelper.TempContent(valueProp.displayName), evtp); cache.Reset(); } else { if (DynamicUtil.TypeIsVariantSupported(propType)) { //draw the default variant as the method accepts anything _variantDrawer.RestrictVariantType = false; _variantDrawer.ForcedObjectType = null; var label = EditorHelper.TempContent("Value", "The value to set to."); _variantDrawer.OnGUI(EditorGUILayout.GetControlRect(true, _variantDrawer.GetPropertyHeight(valueProp, label)), valueProp, label); } else { _variantDrawer.RestrictVariantType = true; _variantDrawer.TypeRestrictedTo = propType; _variantDrawer.ForcedObjectType = (TypeUtil.IsType(propType, typeof(UnityEngine.Object))) ? propType : null; var label = EditorHelper.TempContent("Value", "The value to set to."); _variantDrawer.OnGUI(EditorGUILayout.GetControlRect(true, _variantDrawer.GetPropertyHeight(valueProp, label)), valueProp, label); } } if (com.spacepuppy.Dynamic.Evaluator.WillArithmeticallyCompute(propType)) { EditorGUILayout.PropertyField(modeProp); } else { //modeProp.SetEnumValue(i_SetValue.SetMode.Set); EditorGUI.BeginChangeCheck(); emode = (i_SetValue.SetMode)SPEditorGUILayout.EnumPopupExcluding(EditorHelper.TempContent(modeProp.displayName), emode, i_SetValue.SetMode.Decrement, i_SetValue.SetMode.Increment); if (EditorGUI.EndChangeCheck()) { modeProp.SetEnumValue(emode); } } } else { modeProp.SetEnumValue(i_SetValue.SetMode.Set); } this.serializedObject.ApplyModifiedProperties(); }
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 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; } } }
protected override void OnSPInspectorGUI() { this.serializedObject.Update(); this.DrawDefaultInspectorExcept("_target", "_restrictedType", "_memberName", "_values", "_mode"); this.DrawPropertyField("_target"); //uses the SelectableComponent PropertyDrawer this.DrawPropertyField("_restrictedType"); this.serializedObject.ApplyModifiedProperties(); var targProp = this.serializedObject.FindProperty("_target"); var restrictTypeProp = this.serializedObject.FindProperty("_restrictedType"); var memberProp = this.serializedObject.FindProperty("_memberName"); var valuesArrProp = this.serializedObject.FindProperty("_values"); var modeProp = this.serializedObject.FindProperty("_mode"); var targetRef = EditorHelper.GetTargetObjectOfProperty(targProp) as TriggerableTargetObject; if (targetRef == null) { return; } //SELECT MEMBER System.Reflection.MemberInfo selectedMember = null; var restrictType = TypeReferencePropertyDrawer.GetTypeFromTypeReference(restrictTypeProp); if (restrictType == null && !targetRef.TargetsTriggerArg && targetRef.Target != null && targetRef.Find == TriggerableTargetObject.FindCommand.Direct && targetRef.ResolveBy != TriggerableTargetObject.ResolveByCommand.WithType && targetRef.Target.GetType() != restrictType) { memberProp.stringValue = SPEditorGUILayout.ReflectedPropertyField(EditorHelper.TempContent("Property", "The property on the target to set."), targetRef.Target, memberProp.stringValue, com.spacepuppy.Dynamic.DynamicMemberAccess.ReadWrite, out selectedMember, true); } else { if (restrictType == null) { if (targetRef.ResolveBy == TriggerableTargetObject.ResolveByCommand.WithType) { restrictType = TypeUtil.FindType(targetRef.ResolveByQuery); } if (restrictType == null) { restrictType = typeof(object); } else { TypeReferencePropertyDrawer.SetTypeToTypeReference(restrictTypeProp, restrictType); } } memberProp.stringValue = SPEditorGUILayout.ReflectedPropertyField(EditorHelper.TempContent("Property", "The property on the target to set."), restrictType, memberProp.stringValue, out selectedMember, true); } this.serializedObject.ApplyModifiedProperties(); //MEMBER VALUE TO SET TO if (selectedMember != null && selectedMember.MemberType == System.Reflection.MemberTypes.Method) { var methodInfo = selectedMember as System.Reflection.MethodInfo; if (methodInfo == null) { return; } var parameters = methodInfo.GetParameters(); valuesArrProp.arraySize = parameters.Length; for (int i = 0; i < parameters.Length; i++) { var p = parameters[i]; var valueProp = valuesArrProp.GetArrayElementAtIndex(i); var propType = p.ParameterType; if (DynamicUtil.TypeIsVariantSupported(propType)) { //draw the default variant as the method accepts anything _variantDrawer.RestrictVariantType = false; _variantDrawer.ForcedObjectType = null; var label = EditorHelper.TempContent("Parameter " + i.ToString(), "The value to set to."); _variantDrawer.OnGUI(EditorGUILayout.GetControlRect(true, _variantDrawer.GetPropertyHeight(valueProp, label)), valueProp, label); } else { _variantDrawer.RestrictVariantType = true; _variantDrawer.TypeRestrictedTo = propType; _variantDrawer.ForcedObjectType = (TypeUtil.IsType(propType, typeof(UnityEngine.Object))) ? propType : null; var label = EditorHelper.TempContent("Parameter " + i.ToString(), "The value to set to."); _variantDrawer.OnGUI(EditorGUILayout.GetControlRect(true, _variantDrawer.GetPropertyHeight(valueProp, label)), valueProp, label); } } modeProp.SetEnumValue(i_SetValueOnTarget.SetMode.Set); } else if (selectedMember != null) { var propType = com.spacepuppy.Dynamic.DynamicUtil.GetInputType(selectedMember); var emode = modeProp.GetEnumValue <i_SetValueOnTarget.SetMode>(); if (emode == i_SetValueOnTarget.SetMode.Toggle) { //EditorGUILayout.LabelField(EditorHelper.TempContent(valueProp.displayName), EditorHelper.TempContent(propType.Name)); valuesArrProp.arraySize = 0; var evtp = VariantReference.GetVariantType(propType); var cache = SPGUI.Disable(); EditorGUILayout.EnumPopup(EditorHelper.TempContent("Value"), evtp); cache.Reset(); } else { valuesArrProp.arraySize = 1; var valueProp = valuesArrProp.GetArrayElementAtIndex(0); if (DynamicUtil.TypeIsVariantSupported(propType)) { //draw the default variant as the method accepts anything _variantDrawer.RestrictVariantType = false; _variantDrawer.ForcedObjectType = null; var label = EditorHelper.TempContent("Value", "The value to set to."); _variantDrawer.OnGUI(EditorGUILayout.GetControlRect(true, _variantDrawer.GetPropertyHeight(valueProp, label)), valueProp, label); } else { _variantDrawer.RestrictVariantType = true; _variantDrawer.TypeRestrictedTo = propType; _variantDrawer.ForcedObjectType = (TypeUtil.IsType(propType, typeof(UnityEngine.Object))) ? propType : null; var label = EditorHelper.TempContent("Value", "The value to set to."); _variantDrawer.OnGUI(EditorGUILayout.GetControlRect(true, _variantDrawer.GetPropertyHeight(valueProp, label)), valueProp, label); } } if (com.spacepuppy.Dynamic.Evaluator.WillArithmeticallyCompute(propType)) { EditorGUILayout.PropertyField(modeProp); } else { //modeProp.SetEnumValue(i_SetValueOnTarget.SetMode.Set); EditorGUI.BeginChangeCheck(); emode = (i_SetValueOnTarget.SetMode)SPEditorGUILayout.EnumPopupExcluding(EditorHelper.TempContent(modeProp.displayName), emode, i_SetValueOnTarget.SetMode.Decrement, i_SetValueOnTarget.SetMode.Increment); if (EditorGUI.EndChangeCheck()) { modeProp.SetEnumValue(emode); } } } else { modeProp.SetEnumValue(i_SetValueOnTarget.SetMode.Set); } this.serializedObject.ApplyModifiedProperties(); }
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--; } }
protected void DrawDefaultMaterialSourceInspector() { var prop = this.serializedObject.FindProperty(PROP_RENDERER); var source = this.target as RendererMaterialSource; var go = GameObjectUtil.GetGameObjectFromSource(source); if (go == null) { EditorGUILayout.HelpBox("MaterialSource can not find target GameObject it's attached to.", MessageType.Error); return; } if (Application.isPlaying) { var cache = SPGUI.Disable(); this.DrawPropertyField(PROP_RENDERER); this.DrawPropertyField(PROP_MAKEUNIQUEONSTART); EditorGUILayout.Toggle("Is Unique", source.IsUnique); cache.Reset(); } else { if (prop.objectReferenceValue != null && prop.objectReferenceValue is Renderer) { var renderer = prop.objectReferenceValue as Renderer; if (renderer.gameObject != go) { prop.objectReferenceValue = null; } } var renderers = go.GetComponents <Renderer>(); if (renderers.Length == 0) { EditorGUILayout.HelpBox("MaterialSource can not find a Renderer on that GameObject it's attached to.", MessageType.Error); return; } else { var sources = go.GetComponents <RendererMaterialSource>(); if (sources.Length > renderers.Length) { Debug.LogWarning("There are too many MaterialSources attached to this GameObject. Removing extra.", go); UnityEngine.Object.DestroyImmediate(this.target); return; } renderers = renderers.Except((from s in sources where s.Renderer != null && s.Renderer != source.Renderer select s.Renderer)).ToArray(); var names = (from r in renderers select EditorHelper.TempContent(r.GetType().Name)).ToArray(); int index = renderers.IndexOf(source.Renderer); index = EditorGUILayout.Popup(EditorHelper.TempContent("Renderer"), index, names); if (index >= 0) { prop.objectReferenceValue = renderers[index]; } else { prop.objectReferenceValue = null; } } this.DrawPropertyField(PROP_MAKEUNIQUEONSTART); } }
protected override void OnSPInspectorGUI() { this.serializedObject.Update(); var targ = this.target as ArmatureRig; this.DrawDefaultInspectorExcept("Joints"); var cache = SPGUI.Disable(); EditorGUILayout.FloatField("Mass", targ.CalculateMass()); cache.Reset(); EditorGUI.BeginChangeCheck(); Rigidbody rootJoint = EditorGUILayout.ObjectField("Root Joint", targ.RootJoint, typeof(Rigidbody), true) as Rigidbody; if (EditorGUI.EndChangeCheck()) { if (rootJoint != null) { if (targ.JointCount == 0) { targ.SetJoints(new Rigidbody[] { rootJoint }); } else { using (var lst = TempCollection.GetList <Rigidbody>(targ.Joints)) { lst.Remove(rootJoint); lst.Insert(0, rootJoint); targ.SetJoints(lst); } } this.serializedObject.Update(); } } this.DrawPropertyField("Joints", true); //TODO - implement a button that allows removing and setting the bones of the rig EditorGUILayout.Separator(); if (GUILayout.Button("Build Ragdoll Rig")) { //EditorApplication.ExecuteMenuItem("GameObject/Create Other/Ragdoll..."); com.spacepuppyeditor.Base.SPCreateRagdollWizard.StartWizard(); } if (GUILayout.Button("Generate Joint List")) { targ.ReloadJointList(); targ.LoadJointListOnStart = false; this.serializedObject.Update(); } bool bIsKinematic = false; if (targ.Joints.Count() > 0) { bIsKinematic = targ.Joints.First().isKinematic; } string msg = (bIsKinematic) ? "Set Joints Not Kinematic" : "Set Joints Kinematic"; if (GUILayout.Button(msg)) { targ.SetJointsKinematic(!bIsKinematic); } if (GUILayout.Button("Try Clear Ragdoll Rig")) { if (EditorUtility.DisplayDialog("WARNING!", "Are you sure you want to clear rig?", "Yes", "No")) { //foreach (var t in targ.GetAllChildrenAndSelf()) //{ // if (t.HasComponent<CharacterJoint>()) // { // DestroyImmediate(t.GetComponent<CharacterJoint>()); // DestroyImmediate(t.GetComponent<Collider>()); // DestroyImmediate(t.GetComponent<Rigidbody>()); // } //} targ.ReloadJointList(); foreach (var j in targ.Joints) { if (j.HasComponent <CharacterJoint>()) { DestroyImmediate(j.GetComponent <CharacterJoint>()); } DestroyImmediate(j.GetComponent <Collider>()); DestroyImmediate(j); } targ.SetJoints(null); this.serializedObject.Update(); } } if (GUILayout.Button("Clear Defined Joints")) { if (targ.Joints.Count() > 0) { if (EditorUtility.DisplayDialog("WARNING!", "Are you sure you want to clear all defined joints?", "Yes", "No")) { foreach (var j in targ.Joints) { var go = j.gameObject; DestroyImmediate(go.GetComponent <CharacterJoint>()); DestroyImmediate(go.GetComponent <Collider>()); DestroyImmediate(go.GetComponent <Rigidbody>()); } } targ.SetJoints(null); this.serializedObject.Update(); } } if (Application.isPlaying) { GUILayout.Space(10); if (!targ.Ragdolled) { if (GUILayout.Button("Ragdoll...")) { targ.Ragdoll(); } } else { if (GUILayout.Button("Undo Ragdoll...")) { targ.UndoRagdoll(); } } } }