Exemplo n.º 1
0
 /// <summary>
 /// Moves to the next property.
 /// <param name="enterChildren">Should iterate through the current property children?</param>
 /// <returns>The current property is valid?</returns>
 /// </summary>
 public bool Next(bool enterChildren)
 {
     // The current property has children?
     if (enterChildren && this.m_Current != null && this.m_Current.hasChildren)
     {
         m_ParentPropertiesIndex.Push(m_CurrentIndex);
         m_ParentProperties.Push(m_Properties);
         m_Properties   = this.m_Current.children;
         m_CurrentIndex = 0;
         m_Current      = m_Properties[0];
         return(true);
     }
     // Get next property
     else if (++m_CurrentIndex < m_Properties.Length)
     {
         m_Current = m_Properties[m_CurrentIndex];
         return(true);
     }
     // Restore last property set
     else if (m_ParentProperties.Count > 0)
     {
         m_Properties   = m_ParentProperties.Pop();
         m_CurrentIndex = m_ParentPropertiesIndex.Pop();
         return(this.Next(enterChildren));
     }
     return(false);
 }
        //
        // Methods
        //
        public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent)
        {
            UnityVariablePropertyAttribute att = (UnityVariablePropertyAttribute)attribute;

                        BlackboardCustom blackboard = node.blackboard as BlackboardCustom;

                        List<UnityVariable> blackboardLocalList = blackboard.GetVariableBy (att.variableType);

                        List<GUIContent> displayOptionsList = blackboardLocalList.Select ((item) => new GUIContent ("Local/" + item.name)).ToList ();

                        EditorGUILayout.BeginHorizontal ();

                        //	property.serializedNode.ApplyModifiedProperties ();

                        EditorGUI.BeginChangeCheck ();

                        //EditorGUILayout.LabelField (att.name,new GUILayoutOption[]{GUILayout.MaxWidth(80)});
                        property.value = EditorGUILayoutEx.UnityVariablePopup (new GUIContent(att.name), property.value as UnityVariable, att.variableType, displayOptionsList, blackboardLocalList);

                        if (EditorGUI.EndChangeCheck ()) {
                                property.serializedNode.ApplyModifiedProperties ();
                        }

                        EditorGUILayout.EndHorizontal ();
        }
        /// <summary>
        /// Draw the UnityEngine.Object types pop-up.
        /// </summary>
        public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent)
        {
            // String
            if (property.propertyType == NodePropertyType.String)
            {
                var stringValue = property.value as string ?? string.Empty;
                var rect        = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.popup);
                var id          = GUIUtility.GetControlID(FocusType.Passive);
                var popupRect   = EditorGUI.PrefixLabel(rect, id, guiContent);
                var objectType  = UnityObjectTypeAttribute.GetObjectType(stringValue);

                if (GUI.Button(popupRect, objectType != null ? objectType.ToString() : "None", EditorStyles.popup))
                {
                    var menu = new GenericMenu();

                    // Add None
                    menu.AddItem(new GUIContent("None"), string.IsNullOrEmpty(stringValue), delegate { property.value = string.Empty; });

                    // Add all types that inherit from UnityEngine.Object
                    var types = TypeUtility.GetDerivedTypes(typeof(UnityEngine.Object));
                    for (int i = 0; i < types.Length; i++)
                    {
                        var typeAsString = types[i].ToString();
                        menu.AddItem(new GUIContent(typeAsString.Replace('.', '/')), stringValue == typeAsString, delegate { property.value = typeAsString; });
                    }

                    menu.ShowAsContext();
                }
            }
            // Not String
            else
            {
                EditorGUILayout.LabelField(guiContent, new GUIContent("Use UnityObjectType with string."));
            }
        }
Exemplo n.º 4
0
 /// <summary>
 /// Class constructor.
 /// <param name="target">The target object (node, variable or generic object).</param>
 /// <param name="serializedNode">The target serialized node.</param>
 /// <param name="path">The property path.</param>
 /// <param name="arrayData">The serialize property of the target array.</param>
 /// <param name="array">The target array.</param>
 /// <param name="elementType">The array element type.</param>
 /// </summary>
 public SerializedArraySize(object target, SerializedNode serializedNode, string path, SerializedNodeProperty arrayData, Array array, Type elementType) : base(target, serializedNode, path, typeof(int), NodePropertyType.ArraySize)
 {
     m_ArrayData   = arrayData;
     m_Array       = array;
     m_ElementType = elementType;
     this.label    = "Size";
 }
Exemplo n.º 5
0
 /// <summary>
 /// Called by the serialized properties when their data change.
 /// <param name="property">The property value that has changed.</param>
 /// </summary>
 public void PropertyDataChanged(SerializedNodeProperty property)
 {
     if (property.serializedNode == this && !m_PropertiesChanged.Contains(property))
     {
         m_PropertiesChanged.Add(property);
     }
 }
        public override void OnGUI(SerializedNodeProperty property, BehaviourMachine.ActionNode node, GUIContent guiContent)
        {
            // Now draw the property as a Slider or an IntSlider based on whether it’s a float or integer.
            if ( property.type != typeof(MinMaxRangeSO) )
            Debug.LogWarning( "Use only with MinMaxRange type" );
            else
            {
                var range = attribute as MinMaxRangeSAttribute;
                var so=(MinMaxRangeSO)property.value;

                //set or reset to default full range
                if(so.rangeStart==so.rangeEnd){
                    so.rangeStart=range.minLimit;
                    so.rangeEnd=range.maxLimit;

                }

                var newMin =so.rangeStart;
                var newMax = so.rangeEnd;

            Rect position=	GUILayoutUtility.GetRect(Screen.width-32f,32f);

            var xDivision = position.width * 0.33f;
            var yDivision = position.height * 0.5f;
            EditorGUI.LabelField( new Rect( position.x, position.y, xDivision, yDivision )
                                 , guiContent );

            EditorGUI.LabelField( new Rect( position.x, position.y + yDivision, position.width, yDivision )
                                 , range.minLimit.ToString( "0.##" ) );
            EditorGUI.LabelField( new Rect( position.x + position.width -28f, position.y + yDivision, position.width, yDivision )
                                 , range.maxLimit.ToString( "0.##" ) );

            EditorGUI.MinMaxSlider( new Rect( position.x + 24f, position.y + yDivision, position.width -48f, yDivision )
                                   , ref newMin, ref newMax, range.minLimit, range.maxLimit );

            EditorGUI.LabelField( new Rect( position.x + xDivision, position.y, xDivision, yDivision )
                                 , "From: " );
            newMin = Mathf.Clamp( EditorGUI.FloatField( new Rect( position.x + xDivision + 30, position.y, xDivision -30, yDivision )
                                                       , newMin )
                                 , range.minLimit, newMax );
            EditorGUI.LabelField( new Rect( position.x + xDivision * 2f, position.y, xDivision, yDivision )
                                 , "To: " );
            newMax = Mathf.Clamp( EditorGUI.FloatField( new Rect( position.x + xDivision * 2f + 24, position.y, xDivision -24, yDivision )
                                                       , newMax )
                                 , newMin, range.maxLimit );

            so.rangeStart = newMin;
            so.rangeEnd = newMax;

                property.ValueChanged();

                property.ApplyModifiedValue();

                property.serializedNode.ApplyModifiedProperties();
            }
        }
Exemplo n.º 7
0
        /// <summary>
        /// Draw the UnityEngine.Object using the objectType field.
        /// </summary>
        public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent)
        {
            // Object
            if (property.propertyType == NodePropertyType.UnityObject)
            {
                // Get the type path
                var    attr         = this.attribute as ObjectValueAttribute;
                string path         = property.path;
                int    lastDotIndex = path.LastIndexOf('.');

                if (lastDotIndex > -1)
                {
                    path = path.Remove(lastDotIndex + 1, path.Length - lastDotIndex - 1);
                }
                else
                {
                    path = string.Empty;
                }

                // Get the property iterator
                NodePropertyIterator iterator = property.serializedNode.GetIterator();

                // The type of the object
                string objectTypeAsString = string.Empty;

                // Get the object type as string
                if (iterator.Find(path + attr.typePropertyPath))
                {
                    SerializedNodeProperty typeProperty = iterator.current;
                    objectTypeAsString = typeProperty.value as string ?? string.Empty;
                }

                // Get the object type
                System.Type objectType = !string.IsNullOrEmpty(objectTypeAsString) ? BehaviourMachine.TypeUtility.GetType(objectTypeAsString) ?? typeof(UnityEngine.Object) : typeof(UnityEngine.Object);

                // Used to detect if the gui control was changed
                EditorGUI.BeginChangeCheck();

                // Draw the object gui control
                UnityEngine.Object newValue = EditorGUILayout.ObjectField(guiContent, property.value as UnityEngine.Object, objectType, !AssetDatabase.Contains(node.self));

                // Value changed?
                if (EditorGUI.EndChangeCheck())
                {
                    property.value = newValue;
                }
            }
            // Not Object
            else
            {
                EditorGUILayout.LabelField(guiContent, new GUIContent("Use ObjectValue with UnityEngine.Object."));
            }
        }
Exemplo n.º 8
0
 /// <summary>
 /// Draw the slider.
 /// </summary>
 public override void OnGUI (SerializedNodeProperty property, ActionNode node, GUIContent guiContent) {
     // Integer
     if (property.propertyType == NodePropertyType.Integer) {
         var range = base.attribute as RangeAttribute;
         property.value = EditorGUILayout.IntSlider (guiContent, (int)property.value, (int)range.min, (int)range.max);
     }
     // Float
     else if (property.propertyType == NodePropertyType.Float) {
         var range = base.attribute as RangeAttribute;
         property.value = EditorGUILayout.Slider (guiContent, (float)property.value, range.min, range.max);
     }
     else
         EditorGUILayout.LabelField(guiContent, new GUIContent("Use range with float or int."));
 }
Exemplo n.º 9
0
        /// <summary>
        /// Draw the state pop-up.
        /// </summary>
        public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent)
        {
            // InternalStateBehaviour
            if (property.propertyType == NodePropertyType.UnityObject && property.type == typeof(InternalStateBehaviour))
            {
                var rect      = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.popup);
                var id        = GUIUtility.GetControlID(FocusType.Passive);
                var popupRect = EditorGUI.PrefixLabel(rect, id, guiContent);
                var state     = property.value as InternalStateBehaviour;

                // Set the pop-up color
                var oldGUIColor = GUI.color;
                if (state == null)
                {
                    GUI.color = Color.red;
                }

                if (GUI.Button(popupRect, state != null ? state.stateName : "Null", EditorStyles.popup))
                {
                    // Get states
                    var states = node.tree.states;

                    // Create the pop-up menu
                    var menu = new GenericMenu();

                    // Add null
                    menu.AddItem(new GUIContent("Null"), state == null, delegate() { property.value = (InternalStateBehaviour)null; });

                    // Add states
                    for (int i = 0; i < states.Count; i++)
                    {
                        InternalStateBehaviour currentState = states[i];
                        //setField = field != null ? new SetField(this.target, target, states[i], field, m_Tree) : new SetField(this.target, arrayField, index, states[i], m_Tree);
                        menu.AddItem(new GUIContent(states[i].stateName), state == states[i], delegate() { property.value = currentState; });
                    }

                    // Show menu
                    menu.ShowAsContext();
                }

                // Restore GUI.color
                GUI.color = oldGUIColor;
            }
            else
            {
                EditorGUILayout.LabelField(guiContent, new GUIContent("Use TreeState with InternalStateBehaviour."));
            }
        }
        //
        // Methods
        //
        public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent)
        {
            Enum @enum;

                    if (Enum.IsDefined (this.attribute.GetEnumType (), property.value))
                    {
                        @enum = (Enum)Enum.ToObject (this.attribute.GetEnumType (), property.value);
                    }
                    else
                    {
                        @enum = this.attribute.GetEnumValue ();
                    }

                    @enum=EditorGUILayout.EnumPopup (@enum);

                    property.value= ((int)Convert.ChangeType (@enum, @enum.GetTypeCode ()));
                    property.ApplyModifiedValue ();
        }
Exemplo n.º 11
0
 /// <summary>
 /// Draw the slider.
 /// </summary>
 public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent)
 {
     // Integer
     if (property.propertyType == NodePropertyType.Integer)
     {
         var range = base.attribute as RangeAttribute;
         property.value = EditorGUILayout.IntSlider(guiContent, (int)property.value, (int)range.min, (int)range.max);
     }
     // Float
     else if (property.propertyType == NodePropertyType.Float)
     {
         var range = base.attribute as RangeAttribute;
         property.value = EditorGUILayout.Slider(guiContent, (float)property.value, range.min, range.max);
     }
     else
     {
         EditorGUILayout.LabelField(guiContent, new GUIContent("Use range with float or int."));
     }
 }
        /// <summary>
        /// Draw the property pop-up.
        /// </summary>
        public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent)
        {
            // String
            if (property.propertyType == NodePropertyType.String)
            {
                var rect            = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.popup);
                var id              = GUIUtility.GetControlID(FocusType.Passive);
                var popupRect       = EditorGUI.PrefixLabel(rect, id, guiContent);
                var popupName       = property.value as string ?? string.Empty;
                var propertyOrField = node as PropertyOrField;

                var oldGUIColor = GUI.color;
                if (propertyOrField.propertyType == null)
                {
                    GUI.color = Color.red;
                }

                if (GUI.Button(popupRect, string.IsNullOrEmpty(popupName) ? "None" : popupName, EditorStyles.popup))
                {
                    var isSetProperty = propertyOrField is SetProperty;
                    var members       = FieldUtility.GetPublicMembers(propertyOrField.targetObject.ObjectType, null, false, isSetProperty, !isSetProperty);
                    var menu          = new GenericMenu();

                    // Add none
                    menu.AddItem(new GUIContent("None"), string.IsNullOrEmpty(popupName), delegate() { property.value = string.Empty; });

                    // Add members
                    for (int i = 0; i < members.Length; i++)
                    {
                        var memberName = members[i].Name;
                        menu.AddItem(new GUIContent(memberName), popupName == memberName, delegate() { property.value = memberName; });
                    }

                    menu.ShowAsContext();
                }
                GUI.color = oldGUIColor;
            }
            // Not String
            else
            {
                EditorGUILayout.LabelField(guiContent, new GUIContent("Use UnityObjectProperty with string."));
            }
        }
Exemplo n.º 13
0
        /// <summary>
        /// Draw the UnityEngine.Object using the objectType field.
        /// </summary>
        public override void OnGUI (SerializedNodeProperty property, ActionNode node, GUIContent guiContent) {
            // Object
            if (property.propertyType == NodePropertyType.UnityObject) {
                
                // Get the type path
                var attr = this.attribute as ObjectValueAttribute;
                string path = property.path;
                int lastDotIndex = path.LastIndexOf('.');

                if (lastDotIndex > -1)
                    path = path.Remove(lastDotIndex + 1, path.Length - lastDotIndex - 1);
                else
                    path = string.Empty;

                // Get the property iterator
                NodePropertyIterator iterator = property.serializedNode.GetIterator();

                // The type of the object
                string objectTypeAsString = string.Empty;

                // Get the object type as string
                if (iterator.Find(path + attr.typePropertyPath)) {
                    SerializedNodeProperty typeProperty = iterator.current;
                    objectTypeAsString = typeProperty.value as string ?? string.Empty;
                }

                // Get the object type
                System.Type objectType = !string.IsNullOrEmpty(objectTypeAsString) ? BehaviourMachine.TypeUtility.GetType(objectTypeAsString) ?? typeof(UnityEngine.Object) : typeof(UnityEngine.Object);

                // Used to detect if the gui control was changed
                EditorGUI.BeginChangeCheck();

                // Draw the object gui control
                UnityEngine.Object newValue = EditorGUILayout.ObjectField(guiContent, property.value as UnityEngine.Object, objectType, !AssetDatabase.Contains(node.self));

                // Value changed?
                if (EditorGUI.EndChangeCheck())
                    property.value = newValue;
            }
            // Not Object
            else
                EditorGUILayout.LabelField(guiContent, new GUIContent("Use ObjectValue with UnityEngine.Object."));
        }
Exemplo n.º 14
0
        public void DrawDefaultInspector()
        {
            // Get an iterator
            var iterator = m_SerializedNode.GetIterator();

            // Cache the indent level
            int indentLevel = EditorGUI.indentLevel;

            while (iterator.Next(iterator.current == null || (iterator.current.propertyType != NodePropertyType.Variable && !iterator.current.hideInInspector)))
            {
                SerializedNodeProperty current = iterator.current;
                if (!current.hideInInspector)
                {
                    EditorGUI.indentLevel = indentLevel + iterator.depth;
                    GUILayoutHelper.DrawNodeProperty(new GUIContent(current.label, current.tooltip), current, m_Target);
                }
            }

            // Restore the indent level
            EditorGUI.indentLevel = indentLevel;
        }
Exemplo n.º 15
0
        /// <summary>
        /// Draw the state pop-up.
        /// </summary>
        public override void OnGUI (SerializedNodeProperty property, ActionNode node, GUIContent guiContent) {
            // InternalStateBehaviour
            if (property.propertyType == NodePropertyType.UnityObject && property.type == typeof(InternalStateBehaviour)) {
                var rect = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.popup);
                var id = GUIUtility.GetControlID(FocusType.Passive);
                var popupRect = EditorGUI.PrefixLabel(rect, id, guiContent);
                var state = property.value as InternalStateBehaviour;

                // Set the pop-up color
                var oldGUIColor = GUI.color;
                if (state == null)
                    GUI.color = Color.red;

                if (GUI.Button(popupRect, state != null ? state.stateName : "Null", EditorStyles.popup)) {
                    // Get states
                    var states = node.tree.states;

                    // Create the pop-up menu
                    var menu = new GenericMenu();

                    // Add null
                    menu.AddItem(new GUIContent("Null"), state == null, delegate () {property.value = (InternalStateBehaviour)null;});

                    // Add states
                    for (int i = 0; i < states.Count; i++) {
                        InternalStateBehaviour currentState = states[i];
                        //setField = field != null ? new SetField(this.target, target, states[i], field, m_Tree) : new SetField(this.target, arrayField, index, states[i], m_Tree);
                        menu.AddItem(new GUIContent(states[i].stateName), state == states[i], delegate () {property.value = currentState;});
                    }

                    // Show menu
                    menu.ShowAsContext();
                }

                // Restore GUI.color
                GUI.color = oldGUIColor;
            }
            else
                EditorGUILayout.LabelField(guiContent, new GUIContent("Use TreeState with InternalStateBehaviour."));
        }
Exemplo n.º 16
0
 /// <summary>
 /// Moves to the next property.
 /// <param name="enterChildren">Should iterate through the current property children?</param>
 /// <returns>The current property is valid?</returns>
 /// </summary>
 public bool Next (bool enterChildren) {
     // The current property has children?
     if (enterChildren && this.m_Current != null && this.m_Current.hasChildren) {
         m_ParentPropertiesIndex.Push(m_CurrentIndex);
         m_ParentProperties.Push(m_Properties);
         m_Properties = this.m_Current.children;
         m_CurrentIndex = 0;
         m_Current = m_Properties[0];
         return true;
     }
     // Get next property
     else if (++m_CurrentIndex < m_Properties.Length) {
         m_Current = m_Properties[m_CurrentIndex];
         return true;
     }
     // Restore last property set
     else if (m_ParentProperties.Count > 0) {
         m_Properties = m_ParentProperties.Pop();
         m_CurrentIndex = m_ParentPropertiesIndex.Pop();
         return this.Next(enterChildren);
     }
     return false;
 }
        //
        // Methods
        //
        public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent)
        {
            attribute.serializedObject = node;

                        GUILayout.BeginHorizontal ();

                        if (attribute.Min < attribute.Max) {
                                if (attribute.HasEnableToggle)
                                        attribute.Enabled = GUILayout.Toggle (attribute.Enabled, property.label);

                                if (attribute.Enabled) {

                                        GUILayout.Label (attribute.Min.ToString ());

                                        _valueCurrent = GUILayout.HorizontalSlider (_valueCurrent, attribute.Min, attribute.Max);
                                        property.value = _valueCurrent;
                                        GUILayout.Label (attribute.Max.ToString ());

                                        property.ApplyModifiedValue ();
                                }
                        }

                        GUILayout.EndHorizontal ();
        }
Exemplo n.º 18
0
        /// <summary>
        /// Called by the serialized properties when their data change.
		/// <param name="property">The property value that has changed.</param>
        /// </summary>
        public void PropertyDataChanged (SerializedNodeProperty property) {
            if (property.serializedNode == this && !m_PropertiesChanged.Contains(property))
                m_PropertiesChanged.Add(property);
        }
Exemplo n.º 19
0
        /// <summary>
        /// Show the specified space, clip, node and position.
        /// </summary>
        /// <param name="space">Space.</param>
        /// <param name="clip">Clip.</param>
        /// <param name="node">Node.</param>
        /// <param name="position">Position.</param>
        public static void Show(GameObject space,AnimationClip clip, SerializedNode node, Rect? position)
        {
            MecanimNodeEditorWindow.__spaceGameObject = space;//in this case is character
                        MecanimNodeEditorWindow.__spaceGameObjectAnimationClip = clip;
                        MecanimNodeEditorWindow.__serializedNode = node;

                        ///////   ACCESS SERIALIZED DATA /////////
                        NodePropertyIterator iterator = node.GetIterator ();

                        __isPlaying = false;
                        __isRecording = false;
                        __variableSelected = null;
                        __timeNormalized = 0f;
                        __timeNormalizedUpdate = false;
                        __timeCurrent = 0f;

                        AnimationMode.StopAnimationMode ();
                        Undo.postprocessModifications -= PostprocessAnimationRecordingModifications;

                        SceneView.onSceneGUIDelegate += OnSceneGUI;

                        if (iterator.Find ("clipBindings"))
                                clipBindingsSerialized = iterator.current;

                        if (__mecanimNodeClipBinding == null)
                                __mecanimNodeClipBinding = ScriptableObject.CreateInstance<EditorClipBinding> ();

                        __mecanimNodeClipBinding.gameObject = __spaceGameObject;
                        __mecanimNodeClipBinding.clip = __spaceGameObjectAnimationClip;

                        /////// INIT SERIALIZED NODE PROPERTIES - CURVES, COLORS, VARIABLES //////

                        if (iterator.Find ("curves"))
                                curvesSerialized = iterator.current;
                        else
                                Debug.LogError ("MecananimNode should have public field 'curves'");

                        if (iterator.Find ("curvesColors"))
                                curvesColorsSerialized = iterator.current;
                        else
                                Debug.LogError ("MecananimNode should have public field 'curvesColors'");

                        if (iterator.Find ("variablesBindedToCurves"))
                                variablesBindedToCurvesSerialized = iterator.current;
                        else
                                Debug.LogError ("MecananimNode should have public field 'variablesBindedToCurves'");

                        curves = (AnimationCurve[])curvesSerialized.value;
                        curveColors = (Color[])curvesColorsSerialized.value;
                        variablesBindedToCurves = (UnityVariable[])variablesBindedToCurvesSerialized.value;

                        AnimationModeUtility.ResetBindingsTransformPropertyModification (clipBindingsSerialized.value as EditorClipBinding[]);
                        AnimationModeUtility.ResetBindingTransformPropertyModification (__mecanimNodeClipBinding);

                        keyframeTimeValues = new float[0];
                        eventTimeValuesPrev = new float[0];

                        keyframeTimeValuesSelected = new bool[0];
                        keyframesDisplayNames = new string[0];

                        ///////////// create Reordable list of gameObject-animationClip //////////////////

                        __gameObjectClipList = new ReorderableList (clipBindingsSerialized.value as IList, typeof(EditorClipBinding), true, true, true, true);
                        __gameObjectClipList.drawElementCallback = onDrawElement;

                        __gameObjectClipList.drawHeaderCallback = onDrawHeaderElement;

                        __gameObjectClipList.onRemoveCallback = onRemoveCallback;
                        __gameObjectClipList.onAddCallback = onAddCallback;
                        __gameObjectClipList.onSelectCallback = onSelectCallback;

                        //__gameObjectClipList.elementHeight = 32f;

                        if (MecanimNodeEditorWindow.__window != null)//restore last
                                position = __window.position;

                        MecanimNodeEditorWindow.__window = (MecanimNodeEditorWindow)EditorWindow.GetWindow (typeof(MecanimNodeEditorWindow));

                        if (position.HasValue)
                                MecanimNodeEditorWindow.__window.position = position.Value;

                        MecanimNodeEditorWindow.__window.Show ();
        }
        /// <summary>
        /// Draw the TextArea.
        /// </summary>
        public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent)
        {
            // The text to display
            string text;

            // string
            if (property.propertyType == NodePropertyType.String)
            {
                // Get the text
                text = property.value as string ?? string.Empty;
            }
            // StringVar
            else if (property.propertyType == NodePropertyType.Variable && property.type == typeof(StringVar))
            {
                // Get the text
                var stringVar = property.value as StringVar;
                if (stringVar != null)
                {
                    text = stringVar.Value as string ?? string.Empty;
                }
                else
                {
                    text = string.Empty;
                }
            }
            // Not supported
            else
            {
                EditorGUILayout.LabelField(guiContent, new GUIContent("Use TextAreaAttribute with string or StringVar."));
                return;
            }

            // Create style?
            if (s_Styles == null)
            {
                s_Styles = new NodeTextAreaDrawer.Styles();
            }

            // Get the text area
            var textAreaAttr = (NodeTextAreaAttribute)attribute;

            // Store the current content color
            Color contentColor = GUI.contentColor;

            // The text is empty?
            if (string.IsNullOrEmpty(text))
            {
                text = textAreaAttr.hint;
                Color textColor = EditorStyles.label.normal.textColor;
                textColor.a      = .5f;
                GUI.contentColor = textColor;
            }

            // Draw the text area.
            EditorGUI.BeginChangeCheck();


            #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
            string value = EditorGUILayout.TextArea(text, s_Styles.textArea, GUILayout.Height(16f * textAreaAttr.lines));
            #else
            string value = EditorGUILayout.TextArea(text, s_Styles.textArea, GUILayout.Height(EditorGUIUtility.singleLineHeight * textAreaAttr.lines));
            #endif


            // Check for changes
            if (EditorGUI.EndChangeCheck())
            {
                if (property.propertyType == NodePropertyType.String)
                {
                    property.value = value;
                }
                else
                {
                    // Get the text
                    var stringVar = property.value as StringVar;
                    if (stringVar != null)
                    {
                        stringVar.Value = value;
                        property.ValueChanged();
                    }
                }
            }

            // Restore content color
            GUI.contentColor = contentColor;
        }
Exemplo n.º 21
0
 /// <summary>
 /// Override this method to make your own GUI for the property.
 /// </summary>
 public abstract void OnGUI (SerializedNodeProperty property, ActionNode node, GUIContent guiContent);
Exemplo n.º 22
0
 /// <summary>
 /// Class constructor.
 /// <param name="target">The target object (node, variable or generic object).</param>
 /// <param name="serializedNode">The target serialized node.</param>
 /// <param name="path">The property path.</param>
 /// <param name="arrayData">The serialize property of the target array.</param>
 /// <param name="array">The target array.</param>
 /// <param name="elementType">The array element type.</param>
 /// </summary>
 public SerializedArraySize (object target, SerializedNode serializedNode, string path, SerializedNodeProperty arrayData, Array array, Type elementType) : base (target, serializedNode, path, typeof(int), NodePropertyType.ArraySize) {
     m_ArrayData = arrayData;
     m_Array = array;
     m_ElementType = elementType;
     this.label = "Size";
 }
Exemplo n.º 23
0
        /// <summary>
        /// Draws a node property in the GUI.
        /// <param name="guiContent">The content of the property.</param>
        /// <param name="property">The property do be drawn.</param>
        /// <param name="node">The node that owns the property.</param>
        /// <param name="objectType">An optionaly type to be used to with UnityEngine.Object properties.</param>
        /// <param name="useCustomDrawer">If false the custom node drawer will be ignored if it exists.</param>
        /// </summary>
        public static void DrawNodeProperty(GUIContent guiContent, SerializedNodeProperty property, ActionNode node, Type objectType = null, bool useCustomDrawer = true)
        {
            if (s_Styles == null)
            {
                s_Styles = new GUILayoutHelper.Styles();
            }

            // Get the current value
            object value = property.value;
            // Create the newValue
            object newValue = value;

            // Variable?
            if (property.propertyType == NodePropertyType.Variable)
            {
                GUILayoutHelper.VariableField(guiContent, property, node);
            }
            // Use custom property drawer?
            else if (useCustomDrawer && property.customDrawer != null)
            {
                property.customDrawer.OnGUI(property, node, guiContent);
                return;
            }
            else
            {
                EditorGUI.BeginChangeCheck();

                switch (property.propertyType)
                {
                // Integer
                case NodePropertyType.Integer:
                    newValue = EditorGUILayout.IntField(guiContent, value != null ? (int)value : 0);
                    break;

                // Float
                case NodePropertyType.Float:
                    newValue = EditorGUILayout.FloatField(guiContent, (float)value);
                    break;

                // Boolean
                case NodePropertyType.Boolean:
                    newValue = EditorGUILayout.Toggle(guiContent, (bool)value);
                    break;

                // String
                case NodePropertyType.String:
                    newValue = EditorGUILayout.TextField(guiContent, (string)value);
                    break;

                // Color
                case NodePropertyType.Color:
                    newValue = EditorGUILayout.ColorField(guiContent, (Color)value);
                    break;

                // Vector2
                case NodePropertyType.Vector2:
                        #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                    newValue = EditorGUILayout.Vector2Field(guiContent.text, (Vector2)value);
                        #else
                    newValue = EditorGUILayout.Vector2Field(guiContent, (Vector2)value);
                        #endif
                    break;

                // Vector3
                case NodePropertyType.Vector3:
                        #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                    newValue = EditorGUILayout.Vector3Field(guiContent.text, (Vector3)value);
                        #else
                    newValue = EditorGUILayout.Vector3Field(guiContent, (Vector3)value);
                        #endif
                    break;

                // Quaternion
                case NodePropertyType.Quaternion:
                        #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                    newValue = Quaternion.Euler(EditorGUILayout.Vector3Field(guiContent.text, ((Quaternion)value).eulerAngles));
                        #else
                    newValue = Quaternion.Euler(EditorGUILayout.Vector3Field(guiContent, ((Quaternion)value).eulerAngles));
                        #endif
                    break;

                // Vector4
                case NodePropertyType.Vector4:
                    newValue = EditorGUILayout.Vector4Field(guiContent.text, (Vector4)value);
                    break;

                // Rect
                case NodePropertyType.Rect:
                    newValue = EditorGUILayout.RectField(guiContent, (Rect)value);
                    break;

                // Enum
                case NodePropertyType.Enum:
                    newValue = EditorGUILayout.EnumPopup(guiContent, (System.Enum)value);
                    break;

                // AnimationCurve
                case NodePropertyType.AnimationCurve:
                    newValue = EditorGUILayout.CurveField(guiContent, (AnimationCurve)value);
                    break;

                // UnityObject
                case NodePropertyType.UnityObject:
                    newValue = EditorGUILayout.ObjectField(guiContent, value as UnityEngine.Object, objectType != null ? objectType : property.type, !AssetDatabase.Contains(node.self));
                    break;

                // Array
                case NodePropertyType.Array:
                    EditorGUILayout.LabelField(guiContent);
                    GUI.changed = false;
                    break;

                // ArraySize
                case NodePropertyType.ArraySize:
                    goto case NodePropertyType.Integer;

                // LayerMask
                case NodePropertyType.LayerMask:
                    newValue = GUILayoutHelper.LayerMaskField(guiContent, (LayerMask)value);
                    break;

                // Not Supported
                default:
                    Color oldGuiColor = GUI.color;
                    GUI.color = Color.red;
                    EditorGUILayout.LabelField(guiContent.text, "Not supported.");
                    GUI.color = oldGuiColor;
                    break;
                }

                // Value changed?
                if (EditorGUI.EndChangeCheck())
                {
                    property.value = newValue;
                    Event.current.Use();
                }
            }
        }
Exemplo n.º 24
0
 /// <summary>
 /// Returns the first state of the iterator.
 /// </summary>
 public void Reset()
 {
     m_CurrentIndex = -1;
     m_Current      = null;
 }
Exemplo n.º 25
0
        /// <summary>
        /// Draws a variable field on the GUI.
        /// <param name= "guiContent">The GUI content to draw the property.</param>
        /// <param name= "property">The variable property.</param>
        /// <param name= "node">The node that owns the variable to be drawn.</param>
        /// </summary>
        public static void VariableField(GUIContent guiContent, SerializedNodeProperty property, ActionNode node)
        {
            var variable   = property.value as Variable;
            var isNone     = variable == null || variable.isNone;
            var isConstant = !isNone && variable.isConstant;
            VariableInfoAttribute variableInfo = property.variableInfo;
            string  popupName    = string.Empty;
            Texture popupTexture = null;


            #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
            var rect = GUILayoutUtility.GetRect(guiContent, EditorStyles.popup);
            #else
            var rect = EditorGUILayout.GetControlRect();
            #endif

            var id = GUIUtility.GetControlID(FocusType.Keyboard);

            // Set label color
            if (isNone && variableInfo.requiredField)
            {
                EditorStyles.label.normal.textColor = Color.red;
            }
            // Draw label
            rect = EditorGUI.PrefixLabel(rect, id, guiContent);
            // Restore label color
            EditorStyles.label.normal.textColor = s_Styles.labelTextColor;

            if (isNone)
            {
                popupName    = variableInfo.nullLabel;
                popupTexture = s_Styles.noneTexture;
            }
            else if (isConstant)
            {
                if (property.isConcreteVariable)
                {
                    popupName    = "Constant";
                    popupTexture = s_Styles.constantTexture;
                }
                else
                {
                    popupName    = variable.GetType().Name;
                    popupTexture = IconUtility.GetIcon(variable.GetType());
                }
            }
            else
            {
                popupName = variable.name;
                // Its a global var?
                popupTexture = variable.isGlobal ? s_Styles.globalBlackboardTexture : popupTexture = s_Styles.blackboardTexture;;
            }

            // Popup button
            if (GUIHelper.EditorButton(rect, id, new GUIContent(popupName, popupTexture), s_Styles.popup))
            {
                // Set keyboard focus to the label
                GUIUtility.keyboardControl = id;
                // Create the menu and the list of unique names
                var menu  = new GenericMenu();
                var names = new List <string>()
                {
                };

                // None
                names.Add(variableInfo.nullLabel);
                menu.AddItem(new GUIContent(variableInfo.nullLabel), isNone, delegate {
                    if (isConstant && property.isConcreteVariable)
                    {
                        variable.SetAsNone();
                        property.ValueChanged();
                    }
                    else if (!isNone)
                    {
                        object noneVariable;
                        if (property.type == typeof(GameObjectVar))
                        {
                            noneVariable = Activator.CreateInstance(TypeUtility.GetConcreteType(property.type), new object[] { node.self });
                        }
                        else if (property.type.IsAbstract)
                        {
                            noneVariable = Activator.CreateInstance(TypeUtility.GetConcreteType(property.type));
                        }
                        else
                        {
                            noneVariable = Activator.CreateInstance(property.type);
                        }
                        property.value = noneVariable;
                    }
                });

                // Create the anonymous function to set constants
                GenericMenu.MenuFunction2 createConstant = delegate(object userData) {
                    // Get the desired variable type
                    var type = userData as System.Type;

                    // its not a constant or its an "ex global" var (an ex global var does not have a GlobalBlackboard)?
                    if (variable == null || variable.isInvalid || property.type == typeof(BehaviourMachine.Variable))
                    {
                        // Create a constant
                        Variable newVariable;
                        if (property.type == typeof(GameObjectVar))
                        {
                            newVariable = Activator.CreateInstance(TypeUtility.GetConcreteType(type), new object[] { node.self }) as Variable;
                        }
                        else if (type.IsAbstract)
                        {
                            newVariable = Activator.CreateInstance(TypeUtility.GetConcreteType(type)) as Variable;
                        }
                        else
                        {
                            newVariable = Activator.CreateInstance(type) as Variable;
                        }

                        newVariable.SetAsConstant();
                        property.value = newVariable;
                        property.ValueChanged();
                    }
                    else if (isNone)
                    {
                        variable.SetAsConstant();
                        property.ValueChanged();
                    }
                    else if ((isConstant && !property.isConcreteVariable) || !isConstant)
                    {
                        // Create a concrete variable type and update the field value!
                        Variable newVariable;

                        if (type == typeof(GameObjectVar))
                        {
                            newVariable = Activator.CreateInstance(TypeUtility.GetConcreteType(type), new object[] { node.self }) as Variable;
                        }
                        else if (type.IsAbstract)
                        {
                            newVariable = Activator.CreateInstance(TypeUtility.GetConcreteType(type)) as Variable;
                        }
                        else
                        {
                            newVariable = Activator.CreateInstance(type) as Variable;
                        }

                        newVariable.SetAsConstant();
                        property.value = newVariable;
                    }
                };

                // Add the Constant name to the list
                names.Add("Constant");

                // Can be constant?
                if (variableInfo.canBeConstant && property.type != typeof(BehaviourMachine.FsmEvent) && property.type != typeof(BehaviourMachine.DynamicList))
                {
                    if (property.type != typeof(BehaviourMachine.Variable))
                    {
                        menu.AddItem(new GUIContent("Constant"), isConstant && property.isConcreteVariable, createConstant, property.type);
                    }
                    else
                    {
                        bool variableNotNull = variable != null;
                        // If its a Variable type then add options for all concrete variables
                        if (!variableInfo.fixedType)
                        {
                            menu.AddItem(new GUIContent("Constant/Variable"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.Variable), createConstant, typeof(BehaviourMachine.Variable));
                            menu.AddItem(new GUIContent("Constant/FloatVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteFloatVar), createConstant, typeof(BehaviourMachine.ConcreteFloatVar));
                            menu.AddItem(new GUIContent("Constant/IntVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteIntVar), createConstant, typeof(BehaviourMachine.ConcreteIntVar));
                            menu.AddItem(new GUIContent("Constant/BoolVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteBoolVar), createConstant, typeof(BehaviourMachine.ConcreteBoolVar));
                            menu.AddItem(new GUIContent("Constant/StringVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteStringVar), createConstant, typeof(BehaviourMachine.ConcreteStringVar));
                            menu.AddItem(new GUIContent("Constant/Vector3Var"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteVector3Var), createConstant, typeof(BehaviourMachine.ConcreteVector3Var));
                            menu.AddItem(new GUIContent("Constant/RectVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteRectVar), createConstant, typeof(BehaviourMachine.ConcreteRectVar));
                            menu.AddItem(new GUIContent("Constant/ColorVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteColorVar), createConstant, typeof(BehaviourMachine.ConcreteColorVar));
                            menu.AddItem(new GUIContent("Constant/QuaternionVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteQuaternionVar), createConstant, typeof(BehaviourMachine.ConcreteQuaternionVar));
                            menu.AddItem(new GUIContent("Constant/GameObjectVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteGameObjectVar), createConstant, typeof(BehaviourMachine.ConcreteGameObjectVar));
                            menu.AddItem(new GUIContent("Constant/MaterialVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteMaterialVar), createConstant, typeof(BehaviourMachine.ConcreteMaterialVar));
                            menu.AddItem(new GUIContent("Constant/TextureVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteTextureVar), createConstant, typeof(BehaviourMachine.ConcreteTextureVar));
                            menu.AddItem(new GUIContent("Constant/ObjectVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteObjectVar), createConstant, typeof(BehaviourMachine.ConcreteObjectVar));
                        }
                        else if (variable != null)
                        {
                            // Get the base type
                            System.Type baseType = BehaviourMachine.TypeUtility.GetBaseType(variable.GetType());
                            if (baseType == typeof(Variable))
                            {
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.Variable), createConstant, typeof(BehaviourMachine.Variable));
                            }
                            else if (baseType == typeof(FloatVar))
                            {
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteFloatVar), createConstant, typeof(BehaviourMachine.ConcreteFloatVar));
                            }
                            else if (baseType == typeof(IntVar))
                            {
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteIntVar), createConstant, typeof(BehaviourMachine.ConcreteIntVar));
                            }
                            else if (baseType == typeof(BoolVar))
                            {
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteBoolVar), createConstant, typeof(BehaviourMachine.ConcreteBoolVar));
                            }
                            else if (baseType == typeof(StringVar))
                            {
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteStringVar), createConstant, typeof(BehaviourMachine.ConcreteStringVar));
                            }
                            else if (baseType == typeof(Vector3Var))
                            {
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteVector3Var), createConstant, typeof(BehaviourMachine.ConcreteVector3Var));
                            }
                            else if (baseType == typeof(RectVar))
                            {
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteRectVar), createConstant, typeof(BehaviourMachine.ConcreteRectVar));
                            }
                            else if (baseType == typeof(ColorVar))
                            {
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteColorVar), createConstant, typeof(BehaviourMachine.ConcreteColorVar));
                            }
                            else if (baseType == typeof(QuaternionVar))
                            {
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteQuaternionVar), createConstant, typeof(BehaviourMachine.ConcreteQuaternionVar));
                            }
                            else if (baseType == typeof(GameObjectVar))
                            {
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteGameObjectVar), createConstant, typeof(BehaviourMachine.ConcreteGameObjectVar));
                            }
                            else if (baseType == typeof(MaterialVar))
                            {
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteMaterialVar), createConstant, typeof(BehaviourMachine.ConcreteMaterialVar));
                            }
                            else if (baseType == typeof(TextureVar))
                            {
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteTextureVar), createConstant, typeof(BehaviourMachine.ConcreteTextureVar));
                            }
                            else if (baseType == typeof(ObjectVar))
                            {
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteObjectVar), createConstant, typeof(BehaviourMachine.ConcreteObjectVar));
                            }
                        }
                    }
                }
                else
                {
                    menu.AddDisabledItem(new GUIContent("Constant"));
                }

                // Custom variables
                if (property.type != null)
                {
                    System.Type[] customVars = CustomVariableUtility.GetCustomVariables(variableInfo.fixedType && variable != null ? BehaviourMachine.TypeUtility.GetBaseType(variable.GetType()) : property.type);

                    // if (customVars.Length > 0) {
                    //     menu.AddSeparator(string.Empty);
                    // }

                    for (int i = 0; i < customVars.Length; i++)
                    {
                        // Get the type of the custom variable
                        System.Type customVarType = customVars[i];
                        // Get a unique name
                        string uniqueName = StringHelper.GetUniqueNameInList(names, "Custom/" + customVarType.Name);
                        names.Add(uniqueName);
                        // Add to the menu
                        menu.AddItem(new GUIContent(uniqueName), isConstant && variable != null && variable.GetType() == customVarType, delegate {
                            try {
                                var newVariable = Activator.CreateInstance(customVarType, new object[] { node.self }) as Variable;
                                if (newVariable != null)
                                {
                                    newVariable.SetAsConstant();
                                    property.value = newVariable;
                                }
                            }
                            catch (Exception e) {
                                Print.LogError(e.ToString());
                            }
                        });
                    }
                }

                // Boolean used to know if the variables separator was already added to the menu.
                bool separatorAdded = false;

                // Blackboard variables
                var variables = node.self.GetComponent <InternalBlackboard>().GetVariables(variable != null && variableInfo.fixedType ? BehaviourMachine.TypeUtility.GetBaseType(variable.GetType()) : property.type);

                // Add separator?
                if (variables.Count > 0)
                {
                    menu.AddSeparator(string.Empty);
                    separatorAdded = true;
                }

                // Blackboard variables
                for (int i = 0; i < variables.Count; i++)
                {
                    var v    = variables[i];
                    var name = StringHelper.GetUniqueNameInList(names, v.name);
                    names.Add(name);
                    menu.AddItem(new GUIContent(name), variable == v, delegate { property.value = v; });
                }

                // Global variables
                if (InternalGlobalBlackboard.Instance != null)
                {
                    var globalVariables = InternalGlobalBlackboard.Instance.GetVariables(property.type);

                    // Add separator?
                    if (!separatorAdded && globalVariables.Count > 0)
                    {
                        menu.AddSeparator(string.Empty);
                        separatorAdded = true;
                    }

                    for (int i = 0; i < globalVariables.Count; i++)
                    {
                        var v    = globalVariables[i];
                        var name = StringHelper.GetUniqueNameInList(names, "Global/" + v.name);
                        names.Add(name);
                        menu.AddItem(new GUIContent(name), variable == v, delegate { property.value = v; });
                    }
                }

                // Show menu
                menu.DropDown(rect);
                // Set GUI as not changed
                GUI.changed = false;
            }

            // Draw constant properties
            if (isConstant)
            {
                // Get children
                var children = property.children;

                // The variable is an ObjectVar?
                var         objectVar = variable as ObjectVar;
                System.Type objType   = objectVar != null ? objectVar.ObjectType : null;

                // Draw properties
                if (children.Length > 0)
                {
                    EditorGUI.indentLevel++;

                    if (property.isConcreteVariable)
                    {
                        for (int i = 0; i < children.Length; i++)
                        {
                            SerializedNodeProperty childProperty = children[i];
                            if (!childProperty.hideInInspector)
                            {
                                if (childProperty.propertyType == NodePropertyType.Vector3 || childProperty.propertyType == NodePropertyType.Quaternion || childProperty.propertyType == NodePropertyType.Vector2)
                                {
                                    #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                                    GUILayout.Space(-20f);
                                    EditorGUI.indentLevel--;
                                    #endif

                                    DrawNodeProperty(GUIContent.none, childProperty, node, objType);

                                    #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                                    EditorGUI.indentLevel++;
                                    #endif
                                }
                                else if (childProperty.propertyType == NodePropertyType.Rect)
                                {
                                    #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                                    GUILayout.Space(-20f);
                                    EditorGUI.indentLevel--;
                                    #endif

                                    DrawNodeProperty(GUIContent.none, childProperty, node, objType);

                                    #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                                    GUILayout.Space(20f);
                                    EditorGUI.indentLevel++;
                                    #endif
                                }
                                else
                                {
                                    DrawNodeProperty(new GUIContent(childProperty.label, childProperty.tooltip), childProperty, node, objType);
                                }
                            }
                        }
                    }
                    else
                    {
                        for (int i = 0; i < children.Length; i++)
                        {
                            SerializedNodeProperty childProperty = children[i];
                            if (!childProperty.hideInInspector)
                            {
                                DrawNodeProperty(new GUIContent(childProperty.label, childProperty.tooltip), childProperty, node, objType);
                            }
                        }
                    }

                    EditorGUI.indentLevel--;
                }
            }
        }
Exemplo n.º 26
0
        /// <summary>
        /// Draws a node property in the GUI.
        /// <param name="guiContent">The content of the property.</param>
        /// <param name="property">The property do be drawn.</param>
        /// <param name="node">The node that owns the property.</param>
        /// <param name="objectType">An optionaly type to be used to with UnityEngine.Object properties.</param>
        /// <param name="useCustomDrawer">If false the custom node drawer will be ignored if it exists.</param>
        /// </summary>
        public static void DrawNodeProperty (GUIContent guiContent, SerializedNodeProperty property, ActionNode node, Type objectType = null, bool useCustomDrawer = true) {

            if (s_Styles == null)
                s_Styles = new GUILayoutHelper.Styles();

            // Get the current value
            object value = property.value;
            // Create the newValue
            object newValue = value;

            // Variable?
            if (property.propertyType == NodePropertyType.Variable) {
                GUILayoutHelper.VariableField(guiContent, property, node);
            }
            // Use custom property drawer?
            else if (useCustomDrawer && property.customDrawer != null) {
                property.customDrawer.OnGUI(property, node, guiContent);
                return;
            }
            else {
                EditorGUI.BeginChangeCheck();
                
                switch (property.propertyType) {
                    // Integer
                    case NodePropertyType.Integer:
                        newValue = EditorGUILayout.IntField(guiContent, value != null ? (int) value : 0);
                        break;
                    // Float
                    case NodePropertyType.Float:
                        newValue = EditorGUILayout.FloatField(guiContent, (float) value);
                        break;
                    // Boolean
                    case NodePropertyType.Boolean:
                        newValue = EditorGUILayout.Toggle(guiContent, (bool) value);
                        break;
                    // String
                    case NodePropertyType.String:
                        newValue = EditorGUILayout.TextField(guiContent, (string) value);
                        break;
                    // Color
                    case NodePropertyType.Color:
                        newValue = EditorGUILayout.ColorField(guiContent, (Color) value);
                        break;
                    // Vector2
                    case NodePropertyType.Vector2:
                        #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                        newValue = EditorGUILayout.Vector2Field(guiContent.text, (Vector2) value);
                        #else
                        newValue = EditorGUILayout.Vector2Field(guiContent, (Vector2) value);
                        #endif
                        break;
                    // Vector3
                    case NodePropertyType.Vector3:
                        #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                        newValue = EditorGUILayout.Vector3Field(guiContent.text, (Vector3) value);
                        #else
                        newValue = EditorGUILayout.Vector3Field(guiContent, (Vector3) value);
                        #endif
                        break;
                    // Quaternion
                    case NodePropertyType.Quaternion:
                        #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                        newValue = Quaternion.Euler(EditorGUILayout.Vector3Field(guiContent.text, ((Quaternion)value).eulerAngles));
                        #else
                        newValue = Quaternion.Euler(EditorGUILayout.Vector3Field(guiContent, ((Quaternion)value).eulerAngles));
                        #endif
                        break;
                    // Vector4
                    case NodePropertyType.Vector4:
                        newValue = EditorGUILayout.Vector4Field(guiContent.text, (Vector4) value);
                        break;
                    // Rect
                    case NodePropertyType.Rect:
                        newValue = EditorGUILayout.RectField(guiContent, (Rect) value);
                        break;
                    // Enum
                    case NodePropertyType.Enum:
                        newValue = EditorGUILayout.EnumPopup(guiContent, (System.Enum) value);
                        break;
                    // AnimationCurve
                    case NodePropertyType.AnimationCurve:
                        newValue = EditorGUILayout.CurveField(guiContent, (AnimationCurve) value);
                        break;
                    // UnityObject
                    case NodePropertyType.UnityObject:
                        newValue = EditorGUILayout.ObjectField(guiContent, value as UnityEngine.Object, objectType != null ? objectType : property.type, !AssetDatabase.Contains(node.self));
                        break;
                    // Array
                    case NodePropertyType.Array:
                        EditorGUILayout.LabelField(guiContent);
                        GUI.changed = false;
                        break;
                    // ArraySize
                    case NodePropertyType.ArraySize:
                        goto case NodePropertyType.Integer;
                    // LayerMask
                    case NodePropertyType.LayerMask:
                        newValue = GUILayoutHelper.LayerMaskField(guiContent, (LayerMask) value);
                        break;
                    // Not Supported
                    default:
                        Color oldGuiColor = GUI.color;
                        GUI.color = Color.red;
                        EditorGUILayout.LabelField(guiContent.text, "Not supported.");
                        GUI.color = oldGuiColor;
                        break;
                }

                // Value changed?
                if (EditorGUI.EndChangeCheck()) {
                    property.value = newValue;
                    Event.current.Use();
                }
            }
        }
Exemplo n.º 27
0
 /// <summary>
 /// Constructor.
 /// <param name="members">The serialized properties to iterate through.</param>
 /// </summary>
 public NodePropertyIterator (SerializedNodeProperty[] members) {
     m_Properties = members;
 }
Exemplo n.º 28
0
 /// <summary>
 /// Returns the first state of the iterator.
 /// </summary>
 public void Reset () {
     m_CurrentIndex = -1;
     m_Current = null;
 }
        public override void OnGUI(SerializedNodeProperty property, BehaviourMachine.ActionNode node, GUIContent guiContent)
        {
            Rect position=	GUILayoutUtility.GetRect(Screen.width-32f,32f);

            Rect typePos = new Rect (position.x, position.y, 80, position.height);
            position.xMin = typePos.xMax;
            Rect varPos = new Rect (position.x, position.y, position.width, position.height);

            Type type;

            GUIContent[] displayOptionsTypes;
            Type[] types;

            UniUnityVariablePropertyAttribute attributeUni = attribute as UniUnityVariablePropertyAttribute;

            if (property.value == null)
                type = EditorGUILayoutEx.unityTypes [0];
            else
                type = ((UnityVariable)property.value).ValueType;

            //blackboard vars LOCAL
            BlackboardCustom blackboard = node.blackboard as BlackboardCustom;

            List<UnityVariable> blackboardVariablesLocalList = blackboard.GetVariableBy (type);

            List<GUIContent> displayOptionsVariablesLocal=	 blackboardVariablesLocalList.Select ((item) => new GUIContent ("Local/" + item.name)).ToList();

            //blackboard vars GLOBAL

            if (attributeUni.typesCustom != null) {

                GUIContent[] displayOptionsCustom=attributeUni.typesCustom.Select((itm)=>new GUIContent(itm.Name)).ToArray();

                if(attributeUni.only){
                    types=attributeUni.typesCustom;
                    displayOptionsTypes=displayOptionsCustom;
                }else{

                    types=attributeUni.typesCustom.Concat<Type>(EditorGUILayoutEx.unityTypes).ToArray();

                    displayOptionsTypes = displayOptionsCustom.Concat<GUIContent>(EditorGUILayoutEx.unityTypesDisplayOptions).ToArray();

                }

            }else{

                    displayOptionsTypes=EditorGUILayoutEx.unityTypesDisplayOptions;
                    types=EditorGUILayoutEx.unityTypes;

            }

            //String name = attributeUni.name;

            //create types selection popup
            typeSelected = EditorGUILayoutEx.CustomObjectPopup<Type> (null, type,displayOptionsTypes , types,null,null,null,null,typePos);

                                //if change of type create new variable
                                if (typeSelected != type && !typeSelected.IsSubclassOf (type) /*&& type!=typeof(UnityEngine.Object)*/) {

                                    property.value = UnityVariable.CreateInstanceOf(typeSelected);
                                }

            property.value=EditorGUILayoutEx.UnityVariablePopup(null,property.value as UnityVariable,typeSelected,displayOptionsVariablesLocal,blackboardVariablesLocalList,varPos);

            property.serializedNode.ApplyModifiedProperties();
        }
Exemplo n.º 30
0
 /// <summary>
 /// Update the supplied properties recursively.
 /// <param name="properties">The properties to be updated.</param>
 /// </summary>
 static void UpdatePropertiesRecursively (SerializedNodeProperty[] properties) {
     // Call Update in properties data
     for (int i = 0; i < properties.Length; i++) {
         properties[i].Update();
         if (properties[i].hasChildren)
             UpdatePropertiesRecursively(properties[i].children);
     }
 }
Exemplo n.º 31
0
 /// <summary>
 /// Set the children of the property.
 /// </summary>
 public void SetChildren (SerializedNodeProperty[] children) {
     m_Children = children;
 }
Exemplo n.º 32
0
        /// <summary>
        /// Draws a variable field on the GUI.
        /// <param name= "guiContent">The GUI content to draw the property.</param>
        /// <param name= "property">The variable property.</param>
        /// <param name= "node">The node that owns the variable to be drawn.</param>
        /// </summary>
        public static void VariableField (GUIContent guiContent, SerializedNodeProperty property, ActionNode node) {
            var variable = property.value as Variable;
            var isNone = variable == null || variable.isNone;
            var isConstant = !isNone && variable.isConstant;
            VariableInfoAttribute variableInfo = property.variableInfo;
            string popupName = string.Empty;
            Texture popupTexture = null;


            #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
            var rect = GUILayoutUtility.GetRect(guiContent, EditorStyles.popup);
            #else
            var rect = EditorGUILayout.GetControlRect();
            #endif

            var id = GUIUtility.GetControlID(FocusType.Keyboard);

            // Set label color
            if (isNone && variableInfo.requiredField)
                EditorStyles.label.normal.textColor = Color.red;
            // Draw label
            rect = EditorGUI.PrefixLabel(rect, id, guiContent);
            // Restore label color
            EditorStyles.label.normal.textColor = s_Styles.labelTextColor;
                
            if (isNone) {
                popupName = variableInfo.nullLabel;
                popupTexture = s_Styles.noneTexture;
            }
            else if (isConstant) {
                if (property.isConcreteVariable) {
                    popupName = "Constant";
                    popupTexture = s_Styles.constantTexture;
                }
                else {
                    popupName = variable.GetType().Name;
                    popupTexture = IconUtility.GetIcon(variable.GetType());
                }
            }
            else {
                popupName = variable.name;
                // Its a global var?
                popupTexture = variable.isGlobal ? s_Styles.globalBlackboardTexture : popupTexture = s_Styles.blackboardTexture;;
            }

            // Popup button
            if (GUIHelper.EditorButton(rect, id, new GUIContent(popupName, popupTexture), s_Styles.popup)) {
                // Set keyboard focus to the label
                GUIUtility.keyboardControl = id;
                // Create the menu and the list of unique names
                var menu = new GenericMenu();
                var names = new List<string>() {};

                // None
                names.Add(variableInfo.nullLabel);
                menu.AddItem(new GUIContent(variableInfo.nullLabel), isNone , delegate {
                    if (isConstant && property.isConcreteVariable) {
                        variable.SetAsNone();
                        property.ValueChanged();
                    }
                    else if (!isNone) {
                        object noneVariable;
                        if (property.type == typeof(GameObjectVar))
                            noneVariable = Activator.CreateInstance(TypeUtility.GetConcreteType(property.type), new object[] {node.self});
                        else if (property.type.IsAbstract)
                            noneVariable = Activator.CreateInstance(TypeUtility.GetConcreteType(property.type));
                        else
                            noneVariable = Activator.CreateInstance(property.type);
                        property.value = noneVariable;
                    }
                });

                // Create the anonymous function to set constants
                GenericMenu.MenuFunction2 createConstant = delegate (object userData) {
                    // Get the desired variable type
                    var type = userData as System.Type;
                    
                    // its not a constant or its an "ex global" var (an ex global var does not have a GlobalBlackboard)?
                    if (variable == null || variable.isInvalid || property.type == typeof(BehaviourMachine.Variable)) {
                        // Create a constant
                        Variable newVariable;
                        if (property.type == typeof(GameObjectVar))
                            newVariable = Activator.CreateInstance(TypeUtility.GetConcreteType(type), new object[] {node.self}) as Variable;
                        else if (type.IsAbstract)
                            newVariable = Activator.CreateInstance(TypeUtility.GetConcreteType(type)) as Variable;
                        else
                            newVariable = Activator.CreateInstance(type) as Variable;

                        newVariable.SetAsConstant();
                        property.value = newVariable;
                        property.ValueChanged();
                    }
                    else if (isNone) {
                        variable.SetAsConstant();
                        property.ValueChanged();
                    }
                    else if ((isConstant && !property.isConcreteVariable) || !isConstant) {
                        // Create a concrete variable type and update the field value!
                        Variable newVariable;
                        
                        if (type == typeof(GameObjectVar))
                            newVariable = Activator.CreateInstance(TypeUtility.GetConcreteType(type), new object[] {node.self}) as Variable;
                        else if (type.IsAbstract)
                            newVariable = Activator.CreateInstance(TypeUtility.GetConcreteType(type)) as Variable;
                        else
                            newVariable = Activator.CreateInstance(type) as Variable;
                        
                        newVariable.SetAsConstant();
                        property.value = newVariable;
                    }
                };

                // Add the Constant name to the list
                names.Add("Constant");

                // Can be constant?
                if (variableInfo.canBeConstant && property.type != typeof(BehaviourMachine.FsmEvent) && property.type != typeof(BehaviourMachine.DynamicList)) {
                    if (property.type != typeof(BehaviourMachine.Variable)) {
                        menu.AddItem(new GUIContent("Constant"), isConstant && property.isConcreteVariable, createConstant, property.type);
                    }
                    else {
                        bool variableNotNull = variable != null;
                        // If its a Variable type then add options for all concrete variables
                        if (!variableInfo.fixedType) {
                            menu.AddItem(new GUIContent("Constant/Variable"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.Variable), createConstant, typeof(BehaviourMachine.Variable));
                            menu.AddItem(new GUIContent("Constant/FloatVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteFloatVar), createConstant, typeof(BehaviourMachine.ConcreteFloatVar));
                            menu.AddItem(new GUIContent("Constant/IntVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteIntVar), createConstant, typeof(BehaviourMachine.ConcreteIntVar));
                            menu.AddItem(new GUIContent("Constant/BoolVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteBoolVar), createConstant, typeof(BehaviourMachine.ConcreteBoolVar));
                            menu.AddItem(new GUIContent("Constant/StringVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteStringVar), createConstant, typeof(BehaviourMachine.ConcreteStringVar));
                            menu.AddItem(new GUIContent("Constant/Vector3Var"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteVector3Var), createConstant, typeof(BehaviourMachine.ConcreteVector3Var));
                            menu.AddItem(new GUIContent("Constant/RectVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteRectVar), createConstant, typeof(BehaviourMachine.ConcreteRectVar));
                            menu.AddItem(new GUIContent("Constant/ColorVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteColorVar), createConstant, typeof(BehaviourMachine.ConcreteColorVar));
                            menu.AddItem(new GUIContent("Constant/QuaternionVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteQuaternionVar), createConstant, typeof(BehaviourMachine.ConcreteQuaternionVar));
                            menu.AddItem(new GUIContent("Constant/GameObjectVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteGameObjectVar), createConstant, typeof(BehaviourMachine.ConcreteGameObjectVar));
                            menu.AddItem(new GUIContent("Constant/MaterialVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteMaterialVar), createConstant, typeof(BehaviourMachine.ConcreteMaterialVar));
                            menu.AddItem(new GUIContent("Constant/TextureVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteTextureVar), createConstant, typeof(BehaviourMachine.ConcreteTextureVar));
                            menu.AddItem(new GUIContent("Constant/ObjectVar"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteObjectVar), createConstant, typeof(BehaviourMachine.ConcreteObjectVar));
                        }
                        else if (variable != null) {
                            // Get the base type
                            System.Type baseType = BehaviourMachine.TypeUtility.GetBaseType(variable.GetType());
                            if (baseType == typeof(Variable))
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.Variable), createConstant, typeof(BehaviourMachine.Variable));
                            else if (baseType == typeof(FloatVar))
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteFloatVar), createConstant, typeof(BehaviourMachine.ConcreteFloatVar));
                            else if (baseType == typeof(IntVar))
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteIntVar), createConstant, typeof(BehaviourMachine.ConcreteIntVar));
                            else if (baseType == typeof(BoolVar))
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteBoolVar), createConstant, typeof(BehaviourMachine.ConcreteBoolVar));
                            else if (baseType == typeof(StringVar))
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteStringVar), createConstant, typeof(BehaviourMachine.ConcreteStringVar));
                            else if (baseType == typeof(Vector3Var))
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteVector3Var), createConstant, typeof(BehaviourMachine.ConcreteVector3Var));
                            else if (baseType == typeof(RectVar))
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteRectVar), createConstant, typeof(BehaviourMachine.ConcreteRectVar));
                            else if (baseType == typeof(ColorVar))
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteColorVar), createConstant, typeof(BehaviourMachine.ConcreteColorVar));
                            else if (baseType == typeof(QuaternionVar))
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteQuaternionVar), createConstant, typeof(BehaviourMachine.ConcreteQuaternionVar));
                            else if (baseType == typeof(GameObjectVar))
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteGameObjectVar), createConstant, typeof(BehaviourMachine.ConcreteGameObjectVar));
                            else if (baseType == typeof(MaterialVar))
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteMaterialVar), createConstant, typeof(BehaviourMachine.ConcreteMaterialVar));
                            else if (baseType == typeof (TextureVar))
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteTextureVar), createConstant, typeof(BehaviourMachine.ConcreteTextureVar));
                            else if (baseType == typeof (ObjectVar))
                                menu.AddItem(new GUIContent("Constant"), isConstant && variableNotNull && variable.GetType() == typeof(BehaviourMachine.ConcreteObjectVar), createConstant, typeof(BehaviourMachine.ConcreteObjectVar));
                        }
                    }
                }
                else {
                    menu.AddDisabledItem(new GUIContent("Constant"));
                }

                // Custom variables
                if (property.type != null) {
                    System.Type[] customVars = CustomVariableUtility.GetCustomVariables(variableInfo.fixedType && variable != null ? BehaviourMachine.TypeUtility.GetBaseType(variable.GetType()) : property.type);

                    // if (customVars.Length > 0) {
                    //     menu.AddSeparator(string.Empty);
                    // }

                    for (int i = 0; i < customVars.Length; i++) {
                        // Get the type of the custom variable
                        System.Type customVarType = customVars[i];
                        // Get a unique name
                        string uniqueName = StringHelper.GetUniqueNameInList(names, "Custom/" + customVarType.Name);
                        names.Add(uniqueName);
                        // Add to the menu
                        menu.AddItem(new GUIContent(uniqueName), isConstant && variable != null && variable.GetType() == customVarType, delegate {
                            try {
                                var newVariable = Activator.CreateInstance(customVarType, new object[] {node.self}) as Variable;
                                if (newVariable != null) {
                                    newVariable.SetAsConstant();
                                    property.value = newVariable;
                                }
                            }
                            catch (Exception e) {
                                Print.LogError(e.ToString());
                            }
                        });
                    }
                }

                // Boolean used to know if the variables separator was already added to the menu.
                bool separatorAdded = false;

                // Blackboard variables
                var variables = node.self.GetComponent<InternalBlackboard>().GetVariables(variable != null && variableInfo.fixedType ? BehaviourMachine.TypeUtility.GetBaseType(variable.GetType()) : property.type);

                // Add separator?
                if (variables.Count > 0) {
                    menu.AddSeparator(string.Empty);
                    separatorAdded = true;
                }

                // Blackboard variables
                for (int i = 0; i < variables.Count; i++) {
                    var v = variables[i];
                    var name = StringHelper.GetUniqueNameInList(names, v.name);
                    names.Add(name);
                    menu.AddItem(new GUIContent(name), variable == v , delegate {property.value = v;});
                }

                // Global variables
                if (InternalGlobalBlackboard.Instance != null) {
                    var globalVariables = InternalGlobalBlackboard.Instance.GetVariables(property.type);

                    // Add separator?
                    if (!separatorAdded && globalVariables.Count > 0) {
                        menu.AddSeparator(string.Empty);
                        separatorAdded = true;
                    }

                    for (int i = 0; i < globalVariables.Count; i++) {
                        var v = globalVariables[i];
                        var name = StringHelper.GetUniqueNameInList(names, "Global/" + v.name);
                        names.Add(name);
                        menu.AddItem(new GUIContent(name), variable == v ,  delegate {property.value = v;});
                    }
                }

                // Show menu
                menu.DropDown(rect);
                // Set GUI as not changed
                GUI.changed = false;
            }

            // Draw constant properties
            if (isConstant) {
                // Get children
                var children = property.children;

                // The variable is an ObjectVar?
                var objectVar = variable as ObjectVar;
                System.Type objType = objectVar != null ? objectVar.ObjectType : null;

                // Draw properties
                if (children.Length > 0) {
                    EditorGUI.indentLevel++;

                    if (property.isConcreteVariable) {
                        for (int i = 0; i < children.Length; i++) {
                            SerializedNodeProperty childProperty = children[i];
                            if (!childProperty.hideInInspector) {
                                if (childProperty.propertyType == NodePropertyType.Vector3 || childProperty.propertyType == NodePropertyType.Quaternion || childProperty.propertyType == NodePropertyType.Vector2) {
                                    #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                                    GUILayout.Space(-20f);
                                    EditorGUI.indentLevel--;
                                    #endif
                                    
                                    DrawNodeProperty(GUIContent.none, childProperty, node, objType);
                                    
                                    #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                                    EditorGUI.indentLevel++;
                                    #endif
                                }
                                else if (childProperty.propertyType == NodePropertyType.Rect) {
                                    #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                                    GUILayout.Space(-20f);
                                    EditorGUI.indentLevel--;
                                    #endif
                                   
                                    DrawNodeProperty(GUIContent.none, childProperty, node, objType);
                                   
                                    #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                                    GUILayout.Space(20f);
                                    EditorGUI.indentLevel++;
                                    #endif
                                }
                                else
                                    DrawNodeProperty(new GUIContent(childProperty.label, childProperty.tooltip), childProperty, node, objType);
                            }
                        }
                    }
                    else {
                        for (int i = 0; i < children.Length; i++) {
                            SerializedNodeProperty childProperty = children[i];
                            if (!childProperty.hideInInspector)
                                DrawNodeProperty(new GUIContent(childProperty.label, childProperty.tooltip), childProperty, node, objType);
                        }
                    }
                    
                    EditorGUI.indentLevel--;
                }
            }
        }
Exemplo n.º 33
0
        /// <summary>
        /// Draw the property pop-up.
        /// </summary>
        public override void OnGUI (SerializedNodeProperty property, ActionNode node, GUIContent guiContent) {
            // Create styles?
            if (s_Styles == null)
                s_Styles = new ReflectedPropertyDrawer.Styles();

            // String
            if (property.propertyType == NodePropertyType.String) {
                var popupName = property.value as string ?? string.Empty;
                
                // Get the current vaue of the member
                var memberName = property.value as string ?? string.Empty;
                var attr = this.attribute as ReflectedPropertyAttribute;
                UnityEngine.Object obj = null;
                Component component = null;
                SerializedNodeProperty componentProperty = null;
                SerializedNodeProperty isStaticProperty = null;

                // Get the path
                string path = property.path;
                int lastDotIndex = path.LastIndexOf('.');

                if (lastDotIndex > -1)
                    path = path.Remove(lastDotIndex + 1, path.Length - lastDotIndex - 1);
                else
                    path = string.Empty;

                // Get the property iterator
                NodePropertyIterator iterator = property.serializedNode.GetIterator();

                // Get the game object
                if (iterator.Find(path + attr.objectPropertyPath)) {
                    SerializedNodeProperty objectProperty = iterator.current;
                    obj = objectProperty.value as UnityEngine.Object;
                }

                // Get the isStatic property
                if (iterator.Find(path + attr.isStaticPropertyPath)) {
                    isStaticProperty = iterator.current;
                    if ((bool) isStaticProperty.value)
                        popupName += " (static)";
                }

                // Get the component
                if (iterator.Find(path + attr.componentPropertyPath)) {
                    componentProperty = iterator.current;
                    component = componentProperty.value as Component;
                }

                // Update popup name
                if (string.IsNullOrEmpty(memberName))
                    popupName = "No Property";
                else if (component != null)
                    popupName = component.GetType().Name + "." + popupName;
                else if (obj != null)
                    popupName = obj.GetType().Name + "." + popupName;
                else
                    popupName = "No Property";

                // Get the target type
                System.Type targetType = null;
                if (component != null)
                    targetType = component.GetType();
                else if (obj != null)
                    targetType = obj.GetType();

                // Draw Prefix Label
                if (!FieldUtility.HasMember(targetType, memberName)) {
                    EditorStyles.label.normal.textColor = Color.red;
                }
                var rect = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.popup);
                var id = GUIUtility.GetControlID(FocusType.Passive);
                var popupRect = EditorGUI.PrefixLabel(rect, id, guiContent);

                bool oldGUIEnabled = GUI.enabled;
                GUI.enabled = obj != null;

                if (GUI.Button(popupRect, string.IsNullOrEmpty(popupName) ? "No Property" : popupName, EditorStyles.popup) && obj != null && componentProperty != null && isStaticProperty != null) {
                    var menu = new GenericMenu();

                    // Unique names in the menu
                    var uniqueNames = new List<string>();
                    uniqueNames.Add("No Property");

                    // Add none
                    menu.AddItem(new GUIContent("No Property"), popupName == "No Property", delegate () {componentProperty.value = null; isStaticProperty.value = false; property.value = string.Empty;});

                    // Add separator
                    menu.AddSeparator(string.Empty);

                    string staticName = obj.GetType().Name + "/Static Properties/";

                    // Add Object static members
                    var members = FieldUtility.GetPublicMembers(obj.GetType(), attr.propertyType, true, true, true);
                    if (members.Length > 0) {
                        for (int i = 0; i < members.Length; i++) {
                            var currentMemberName = members[i].Name;
                            menu.AddItem(new GUIContent(staticName + currentMemberName), component == null && currentMemberName == memberName, delegate () {componentProperty.value = null; isStaticProperty.value = true; property.value = currentMemberName;});
                        }
                    }

                    // Add Object members
                    members = FieldUtility.GetPublicMembers(obj.GetType(), attr.propertyType, false, true, true);
                    for (int i = 0; i < members.Length; i++) {
                        var currentMemberName = members[i].Name;
                        menu.AddItem(new GUIContent(obj.GetType().Name + "/" +  currentMemberName), component == null && currentMemberName == memberName, delegate () {componentProperty.value = null; isStaticProperty.value = false; property.value = currentMemberName;});
                    }

                    // Add components
                    var gameObject = obj as GameObject;
                    if (gameObject != null) {
                        Component[] components = gameObject.GetComponents<Component>();
                        for (int i = 0; i < components.Length; i++) {
                            // Get the current componet
                            Component currentComponent = components[i];
                            // Get the component type
                            System.Type componentType = currentComponent.GetType();

                            // Get a unique name for the component names
                            string componentName = StringHelper.GetUniqueNameInList(uniqueNames, componentType.Name);
                            uniqueNames.Add(componentName);

                            // Add static members
                            staticName = componentName + "/Static Properties/";
                            members = FieldUtility.GetPublicMembers(currentComponent.GetType(), attr.propertyType, true, true, true);
                            if (members.Length > 0) {
                                for (int j = 0; j < members.Length; j++) {
                                    var currentMemberName = members[j].Name;
                                    menu.AddItem(new GUIContent(staticName +  currentMemberName), currentComponent == component && currentMemberName == memberName, delegate () {componentProperty.value = currentComponent; isStaticProperty.value = true; property.value = currentMemberName;});
                                }
                            }

                            // Get members
                            members = FieldUtility.GetPublicMembers(currentComponent.GetType(), attr.propertyType, false, true, true);

                            // Add members
                            for (int j = 0; j < members.Length; j++) {
                                var currentMemberName = members[j].Name;
                                menu.AddItem(new GUIContent(componentName + "/" +  currentMemberName), currentComponent == component && currentMemberName == memberName, delegate () {componentProperty.value = currentComponent; isStaticProperty.value = false; property.value = currentMemberName;});
                            }
                        }
                    }

                    menu.ShowAsContext();   
                }

                // Restore olde gui enabled
                GUI.enabled = oldGUIEnabled;

                // Restore label color
                EditorStyles.label.normal.textColor = s_Styles.labelTextColor;
            }
            // Not String
            else
                EditorGUILayout.LabelField(guiContent, new GUIContent("Use UnityObjectReflectProperty with string."));
        }
Exemplo n.º 34
0
 /// <summary>
 /// Override this method to make your own GUI for the property.
 /// </summary>
 public abstract void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent);
Exemplo n.º 35
0
        /// <summary>
        /// The custom inspector.
        /// </summary>
        public override void OnInspectorGUI()
        {
            DrawDefaultInspector();

            var randomChild = target as RandomChild;

            if (randomChild != null)
            {
                // Get children nodes
                ActionNode[] children = randomChild.children;

                // Update serialized node data
                if (Event.current.type == EventType.Layout)
                {
                    this.serializedNode.Update();
                }

                // Get an iterator
                var iterator = serializedNode.GetIterator();

                // Cache the indent level
                int indentLevel = EditorGUI.indentLevel;

                if (iterator.Find("weight"))
                {
                    SerializedNodeProperty current = iterator.current;

                    // Cache the depth of array name
                    int depth = iterator.depth;

                    // Don't draw the size
                    iterator.Next(true);

                    // The current index of the child
                    int childIndex = 0;

                    // Draw children weight
                    while (iterator.Next(iterator.current == null || iterator.current.propertyType != NodePropertyType.Variable) && iterator.depth > depth)
                    {
                        current = iterator.current;
                        if (!current.hideInInspector)
                        {
                            EditorGUI.indentLevel = indentLevel + iterator.depth - 1;

                            // Its an array element of  weight array?
                            if (iterator.depth - depth == 1 && childIndex < children.Length)
                            {
                                GUILayoutHelper.DrawNodeProperty(new GUIContent(children[childIndex++].name + " Weight", current.tooltip), current, target);
                            }
                            else
                            {
                                GUILayoutHelper.DrawNodeProperty(new GUIContent(current.label, current.tooltip), current, target);
                            }
                        }
                    }
                }

                // Restore the indent level
                EditorGUI.indentLevel = indentLevel;

                // Apply modified properties
                this.serializedNode.ApplyModifiedProperties();
            }
        }
Exemplo n.º 36
0
        /// <summary>
        /// The custom inspector.
        /// </summary>
        public override void OnInspectorGUI()
        {
            int i = 0;

                        //////  RESTORE SAVED  //////
                        //restore and delete clipboard

                        mecanimNode = target as MecanimNode;

                        if (mecanimNode != null) {

                                Motion motion = null;

                                //////////////////////////////////////////////////////////////
                                /// 						PRESEVE RESTORE					//
                                if (EditorApplication.isPlaying || EditorApplication.isPaused) {

                                        if (GUILayout.Button ("Preserve")) {

                                                serializedNode.ApplyModifiedProperties ();

                                                UnityVariable.SetDirty (mecanimNode.blendX);

                                                UnityVariable.SetDirty (mecanimNode.blendY);
                                                UnityVariable.SetDirty (mecanimNode.motionOverride);

            //												if (variablesBindedToCurves != null) {
            //														UnityVariable[] varArray = variablesBindedToCurves;
            //
            //														int varNumber = varArray.Length;
            //														for (int varCurrent=0; varCurrent<varNumber; varCurrent++) {
            //																varArray [varCurrent].OnBeforeSerialize ();
            //
            //														}
            //												}

                                                EditorUtilityEx.Clipboard.preserve (mecanimNode.instanceID, mecanimNode, mecanimNode.GetType ().GetFields ());

                                        }
                                } else {
                                        if (EditorUtilityEx.Clipboard.HasBeenPreseved (mecanimNode.instanceID) && GUILayout.Button ("Apply Playmode Changes")) {
                                                EditorUtilityEx.Clipboard.restore (mecanimNode.instanceID, mecanimNode);

                                                animatorStateSerialized = null;
                                                NodePropertyIterator iterator = serializedNode.GetIterator ();

                                                while (iterator.Next (true)) {
                                                        if (iterator.current.value is UnityVariable) {
                                                                //Debug.Log("OnBeforeDeserialize:"+((UnityVariable)iterator.current.value).Value);
                                                                ((UnityVariable)iterator.current.value).OnAfterDeserialize ();

                                                                //Debug.Log("OnAfterDeserialize:"+((UnityVariable)iterator.current.value).Value);
                                                        } else if (iterator.current.value is UnityVariable[]) {

                                                                UnityVariable[] varArray = (UnityVariable[])iterator.current.value;
                                                                int varNumber = varArray.Length;
                                                                for (int varCurrent=0; varCurrent<varNumber; varCurrent++) {
                                                                        varArray [varCurrent].OnAfterDeserialize ();

                                                                }

                                                        }

                                                        iterator.current.ValueChanged ();

                                                        this.serializedNode.Update ();

                                                        iterator.current.ApplyModifiedValue ();

                                                }

                                        }

                                }
                                //////////////////////

                                if (Event.current.type == EventType.Layout) {
                                        this.serializedNode.Update ();

                                }

                                DrawDefaultInspector ();

            //
            //				if (EditorGUILayoutEx.ANIMATION_STYLES == null)
            //					EditorGUILayoutEx.ANIMATION_STYLES = new EditorGUILayoutEx.AnimationStyles ();

                                /////////////////////////////// ANIMATOR STATE /////////////////////////////////

                                if (animatorStateSerialized == null) {
                                        NodePropertyIterator iterator = this.serializedNode.GetIterator ();
                                        if (iterator.Find ("animatorStateSelected"))
                                                animatorStateSerialized = iterator.current;

                                        if (iterator.Find ("motionOverride"))
                                                motionOverrideSerialized = iterator.current;
                                }

                                //////////  MOTION OVERRIDE HANDLING  //////////
                                if (animatorStateSerialized.value != null) {

                                        UnityVariable motionOverridVariable = (UnityVariable)motionOverrideSerialized.value;

                                        //if there are no override use motion of selected AnimationState
                                        //Debug.Log(((UnityEngine.Object)mecanimNode.motionOverride.Value).);
                                        if (motionOverridVariable == null || motionOverridVariable.Value == null || motionOverridVariable.ValueType != typeof(AnimationClip))
                                                motion = ((ws.winx.unity.AnimatorState)animatorStateSerialized.value).motion;
                                        else //
                                                motion = (Motion)motionOverridVariable.Value;

                                        if (motionOverridVariable != null && motionOverridVariable.Value != null && ((ws.winx.unity.AnimatorState)animatorStateSerialized.value).motion == null) {
                                                Debug.LogError ("Can't override state that doesn't contain motion");
                                        }

                                }
                                ///////////////////////////////////////////////////

                                if (GUILayout.Button ("BindEditor") && motion!=null) {

                                    MecanimNodeEditorWindow.Show ( mecanimNode.self, motion as AnimationClip, this.serializedNode, null);
                                }

                                /////////////   TIME CONTROL OF ANIMATION (SLIDER) /////////
                                if (Application.isPlaying) {

                                        if (animatorStateRuntimeControlEnabledSerialized == null) {
                                                NodePropertyIterator iterator = this.serializedNode.GetIterator ();

                                                if (iterator.Find ("animationRunTimeControlEnabled")) {
                                                        animatorStateRuntimeControlEnabledSerialized = iterator.current;
                                                }

                                                if (iterator.Find ("animatorStateRunTimeControl")) {
                                                        animatorStateRunTimeControlSerialized = iterator.current;
                                                }
                                        }

                                        if (animatorStateRuntimeControlEnabledSerialized != null && animatorStateRunTimeControlSerialized != null && (bool)animatorStateRuntimeControlEnabledSerialized.value) {
                                                Rect timeControlRect = GUILayoutUtility.GetRect (Screen.width - 16f, 26f);
                                                timeControlRect.xMin += 38f;
                                                timeControlRect.xMax -= 70f;
                                                animatorStateRunTimeControlSerialized.value = EditorGUILayoutEx.CustomHSlider (timeControlRect, (float)animatorStateRunTimeControlSerialized.value, 0f, 1f,EditorGUILayoutEx.ANIMATION_STYLES.timeScrubber);

                                        }

                                }
                                ///////////////////////////////////////////////////////////////

                                /////////// AVATAR Preview GUI ////////////

                                if (!Application.isPlaying && motion != null) {

                                        //This makes layout to work (Reserving space)
                                        Rect avatarRect = GUILayoutUtility.GetRect (Screen.width - 16f, 200);
                                        avatarRect.width -= 70f;
                                        avatarRect.xMin += 6f;

                                        if (avatarPreview == null)
                                                avatarPreview = new AvatarPreviewW (null, motion);
                                        else
                                                avatarPreview.SetPreviewMotion (motion);

                                        EditorGUILayout.BeginHorizontal ();

                                        if (eventTimeValues != null && Event.current.type == EventType.Repaint) {

                                                //find first selected if exist
                                                int eventTimeValueSelectedIndex = Array.IndexOf (eventTimeValuesSelected, true);

                                                if (eventTimeValueSelectedIndex > -1) {
                                                        avatarPreview.SetTimeAt (eventTimeValues [eventTimeValueSelectedIndex]);
                                                } else {

                                                        //!!! changing
                                                        //avatarPreview.timeControl.startTime
                                                        // start/stop makes AvatarPreview to play from start to stop
                                                        // and the rest of animation isn't visible in Timeline so not good for selecting range
                                                        // but its not offer good usability of resized animation

                                                        if (avatarPreview.timeControl.playing) {

                                                                //restrict animation into this range
                                                                if (avatarPreview.timeControl.normalizedTime < mecanimNode.range.rangeStart || avatarPreview.timeControl.normalizedTime > mecanimNode.range.rangeEnd) {

                                                                        avatarPreview.timeControl.nextCurrentTime = avatarPreview.timeControl.startTime * (1f - mecanimNode.range.rangeStart) + avatarPreview.timeControl.stopTime * mecanimNode.range.rangeStart;

                                                                }
                                                        } else {

                                                                //set AvatarPreview animation time range depending of drag of range control handles
                                                                if (Math.Abs (mecanimNode.range.rangeStart - timeNormalizedStartPrev) > 0.01f) {
                                                                        timeNormalizedStartPrev = mecanimNode.range.rangeStart;

                                                                        avatarPreview.SetTimeAt (timeNormalizedStartPrev);

                                                                } else
                                                                if (Math.Abs (mecanimNode.range.rangeEnd - timeNormalizedEndPrev) > 0.01f) {
                                                                        timeNormalizedEndPrev = mecanimNode.range.rangeEnd;
                                                                        avatarPreview.SetTimeAt (timeNormalizedEndPrev);

                                                                }

                                                        }

                                                }

                                        }

                                        avatarPreview.timeControl.playbackSpeed = mecanimNode.speed;

                                        avatarPreview.DoAvatarPreview (avatarRect, GUIStyle.none);

                                        //Debug.Log(avatarPreview.timeControl.currentTime+" "+);
                                        EditorGUILayout.EndHorizontal ();

                                        ////////// Events Timeline GUI //////////

                                        if (!eventTimeLineInitalized) {

                                                //TODO calculate PopupRect

                                                eventTimeLineValuePopUpRect = new Rect ((Screen.width - 250) * 0.5f, (Screen.height - 150) * 0.5f, 250, 150);

                                                //select the time values from nodes
                                                //eventTimeValues = mecanimNode.children.Select ((val) => (float)((SendEventNormalized)val).timeNormalized.Value).ToArray ();

                                                eventTimeValues = mecanimNode.children.Select ((val) => (float)((SendEventNormalizedNode)val).timeNormalized.serializedProperty.floatValue).ToArray ();

                                                eventDisplayNames = mecanimNode.children.Select ((val) => ((SendEventNormalizedNode)val).name).ToArray ();
                                                eventTimeValuesSelected = new bool[eventTimeValues.Length];

                                                playButtonStyle = "TimeScrubberButton";

                                                if (playButtonStyle != null)
                                                        playButtonSize = playButtonStyle.CalcSize (new GUIContent ());

                                                eventTimeLineInitalized = true;
                                        }

                                        Rect timeLineRect = GUILayoutUtility.GetRect (Screen.width - 16f, 50f);
                                        //Rect timeLineRect = GUILayoutUtility.GetLastRect ();

                                        Texture eventMarkerTexture = EditorGUILayoutEx.ANIMATION_STYLES.eventMarker.image;
                                        timeLineRect.xMin += playButtonSize.x - eventMarkerTexture.width * 0.5f;
                                        timeLineRect.xMax -= eventMarkerTexture.width * 0.5f;
                                        //timeLineRect.height = EditorGUILayoutEx.eventMarkerTexture.height * 3 * 0.66f + playButtonSize.y;
                                        timeLineRect.width -= 66f;
                                        EditorGUILayoutEx.CustomTimeLine (ref timeLineRect,new GUIContent(eventMarkerTexture), ref eventTimeValues, ref eventTimeValuesPrev, ref eventDisplayNames, ref eventTimeValuesSelected, avatarPreview.timeControl.normalizedTime,
                                                  onMecanimEventAdd, onMecanimEventDelete, onMecanimEventClose, onMecanimEventEdit, onMecanimEventDragEnd
                                        );

                                        EditorGUILayout.LabelField ("Events Timeline");

                                        SendEventNormalizedNode ev;

                                        //update time values
                                        int eventTimeValuesNumber = mecanimNode.children.Length;
                                        for (i=0; i<eventTimeValuesNumber; i++) {
                                                ev = ((SendEventNormalizedNode)mecanimNode.children [i]);
                                                //ev.timeNormalized.Value = eventTimeValues [i];
                                                ev.timeNormalized.Value = eventTimeValues [i];

                                                //if changes have been made in pop editor or SendEventNormailized inspector
                                                if (ev.name != eventDisplayNames [i])
                                                        eventDisplayNames [i] = ((SendEventNormalizedNode)mecanimNode.children [i]).name;

                                                ev.timeNormalized.ApplyModifiedProperties ();

                                        }

                                        // Restore the indent level
                                        //EditorGUI.indentLevel = indentLevel;

                                        // Apply modified properties
                                        this.serializedNode.ApplyModifiedProperties ();

                                }

                        }
        }
        //
        // Methods
        //
        /// <summary>
        /// Handles the onGUI event.
        /// </summary>
        /// <param name="property">Property.</param>
        /// <param name="node">Node.</param>
        /// <param name="guiContent">GUI content.</param>
        public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent)
        {
            //if (animatorSerialized == null || aniController == null) {
                        if(aniController == null) {

                                //!!! Serialization never serialized Animator cos its initialized in Reset after
            //								NodePropertyIterator iter= property.serializedNode.GetIterator();
            //								iter.Find(attribute.animatorFieldName);
            //								 animatorSerialized=iter.current;
                                //				//								if(animatorSerialized==null || animatorSerialized.value==null){
                                //										Debug.LogError("AnimatorStateNodePropertyDrawer> No Animator component set on node parent GameObject");
                                //									return;
                                //								}

                                //runtimeContoller =( (Animator)animatorSerialized.value).runtimeAnimatorController;
                                Animator animator = node.GetType ().GetField (attribute.animatorFieldName).GetValue (node) as Animator;

                                RuntimeAnimatorController runtimeContoller;

                                runtimeContoller = animator.runtimeAnimatorController;

                                if (runtimeContoller is AnimatorOverrideController)
                                        aniController = ((AnimatorOverrideController)runtimeContoller).runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
                                else
                                        aniController = runtimeContoller as UnityEditor.Animations.AnimatorController;

                        }

                        animatorStateDisplayOptions = MecanimUtility.GetDisplayOptions (aniController);
                        animatorStateValues = MecanimUtility.GetAnimatorStates (aniController);

                        if(property.value!=null){

                            if(animatorStateValues.Length>0){
                                    animatorStateSelectedPrev=animatorStateSelected=animatorStateValues.FirstOrDefault((itm)=>itm.nameHash==((ws.winx.unity.AnimatorState)property.value).nameHash);

                            }
                        }

                        animatorStateSelected = EditorGUILayoutEx.CustomObjectPopup (guiContent, animatorStateSelected, animatorStateDisplayOptions, animatorStateValues);//,compare);

                        //TODO try Begin/End Check
                        if (animatorStateSelectedPrev != animatorStateSelected) {

                                NodePropertyIterator iter = property.serializedNode.GetIterator ();
                                iter.Find (attribute.layerIndexFieldName);
                                SerializedNodeProperty layerIndexSerialized = iter.current;

                                layerIndexSerialized.value = MecanimUtility.GetLayerIndex (aniController, animatorStateSelected);
                                layerIndexSerialized.ApplyModifiedValue ();

                                    ws.winx.unity.AnimatorState state=property.value as ws.winx.unity.AnimatorState;
                                    if(state==null) state=ScriptableObject.CreateInstance<ws.winx.unity.AnimatorState>();

                                    state.motion=animatorStateSelected.motion;
                                    state.nameHash=animatorStateSelected.nameHash;
                                    state.layer=(int)layerIndexSerialized.value;

                                    if(state.motion is UnityEditor.Animations.BlendTree){
                                        BlendTree tree =(BlendTree)state.motion;
                                        int blendParamsNum= tree.GetRecursiveBlendParamCount();

                                        state.blendParamsHashes=new int[blendParamsNum];

                                        for(int i=0;i<blendParamsNum;i++)
                                            state.blendParamsHashes[i]=Animator.StringToHash(tree.GetRecursiveBlendParam(i));

                                    }else{
                                            state.blendParamsHashes=null;
                                    }

                                    //property.value=state;
                                    property.ValueChanged();

                                property.ApplyModifiedValue ();

                                animatorStateSelectedPrev = animatorStateSelected;
                        }

                        if (animatorStateSelected.motion == null)
                                Debug.LogError ("Selected state doesn't have Motion set");
        }
Exemplo n.º 38
0
        /// <summary>
        /// Draw the TextArea.
        /// </summary>
        public override void OnGUI (SerializedNodeProperty property, ActionNode node, GUIContent guiContent) {
            // The text to display
            string text;

            // string
            if (property.propertyType == NodePropertyType.String) {
                // Get the text
                text = property.value as string ?? string.Empty;
            }
            // StringVar
            else if (property.propertyType == NodePropertyType.Variable && property.type == typeof(StringVar)) {
                // Get the text
                var stringVar = property.value as StringVar;
                if (stringVar != null)
                    text = stringVar.Value as string ?? string.Empty;
                else
                    text = string.Empty;
            }
            // Not supported
            else {
                EditorGUILayout.LabelField(guiContent, new GUIContent("Use TextAreaAttribute with string or StringVar."));
                return;
            }

            // Create style?
            if (s_Styles == null)
                s_Styles = new NodeTextAreaDrawer.Styles();

            // Get the text area
            var textAreaAttr = (NodeTextAreaAttribute) attribute;

            // Store the current content color
            Color contentColor = GUI.contentColor;

            // The text is empty?
            if (string.IsNullOrEmpty(text)) {
                text = textAreaAttr.hint;
                Color textColor = EditorStyles.label.normal.textColor;
                textColor.a = .5f;
                GUI.contentColor = textColor;
            }

            // Draw the text area.
            EditorGUI.BeginChangeCheck ();


            #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
            string value = EditorGUILayout.TextArea (text, s_Styles.textArea, GUILayout.Height(16f * textAreaAttr.lines));
            #else
            string value = EditorGUILayout.TextArea (text, s_Styles.textArea, GUILayout.Height(EditorGUIUtility.singleLineHeight * textAreaAttr.lines));
            #endif
            

            // Check for changes
            if (EditorGUI.EndChangeCheck ()) {
                if (property.propertyType == NodePropertyType.String)
                    property.value = value;
                else {
                    // Get the text
                    var stringVar = property.value as StringVar;
                    if (stringVar != null) {
                        stringVar.Value = value;
                        property.ValueChanged();
                    }
                }
            }

            // Restore content color
            GUI.contentColor = contentColor;
        }
        /// <summary>
        /// Draw the property pop-up.
        /// </summary>
        public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent)
        {
            // Create styles?
            if (s_Styles == null)
            {
                s_Styles = new ReflectedPropertyDrawer.Styles();
            }

            // String
            if (property.propertyType == NodePropertyType.String)
            {
                var popupName = property.value as string ?? string.Empty;

                // Get the current vaue of the member
                var memberName                           = property.value as string ?? string.Empty;
                var attr                                 = this.attribute as ReflectedPropertyAttribute;
                UnityEngine.Object     obj               = null;
                Component              component         = null;
                SerializedNodeProperty componentProperty = null;
                SerializedNodeProperty isStaticProperty  = null;

                // Get the path
                string path         = property.path;
                int    lastDotIndex = path.LastIndexOf('.');

                if (lastDotIndex > -1)
                {
                    path = path.Remove(lastDotIndex + 1, path.Length - lastDotIndex - 1);
                }
                else
                {
                    path = string.Empty;
                }

                // Get the property iterator
                NodePropertyIterator iterator = property.serializedNode.GetIterator();

                // Get the game object
                if (iterator.Find(path + attr.objectPropertyPath))
                {
                    SerializedNodeProperty objectProperty = iterator.current;
                    obj = objectProperty.value as UnityEngine.Object;
                }

                // Get the isStatic property
                if (iterator.Find(path + attr.isStaticPropertyPath))
                {
                    isStaticProperty = iterator.current;
                    if ((bool)isStaticProperty.value)
                    {
                        popupName += " (static)";
                    }
                }

                // Get the component
                if (iterator.Find(path + attr.componentPropertyPath))
                {
                    componentProperty = iterator.current;
                    component         = componentProperty.value as Component;
                }

                // Update popup name
                if (string.IsNullOrEmpty(memberName))
                {
                    popupName = "No Property";
                }
                else if (component != null)
                {
                    popupName = component.GetType().Name + "." + popupName;
                }
                else if (obj != null)
                {
                    popupName = obj.GetType().Name + "." + popupName;
                }
                else
                {
                    popupName = "No Property";
                }

                // Get the target type
                System.Type targetType = null;
                if (component != null)
                {
                    targetType = component.GetType();
                }
                else if (obj != null)
                {
                    targetType = obj.GetType();
                }

                // Draw Prefix Label
                if (!FieldUtility.HasMember(targetType, memberName))
                {
                    EditorStyles.label.normal.textColor = Color.red;
                }
                var rect      = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.popup);
                var id        = GUIUtility.GetControlID(FocusType.Passive);
                var popupRect = EditorGUI.PrefixLabel(rect, id, guiContent);

                bool oldGUIEnabled = GUI.enabled;
                GUI.enabled = obj != null;

                if (GUI.Button(popupRect, string.IsNullOrEmpty(popupName) ? "No Property" : popupName, EditorStyles.popup) && obj != null && componentProperty != null && isStaticProperty != null)
                {
                    var menu = new GenericMenu();

                    // Unique names in the menu
                    var uniqueNames = new List <string>();
                    uniqueNames.Add("No Property");

                    // Add none
                    menu.AddItem(new GUIContent("No Property"), popupName == "No Property", delegate() { componentProperty.value = null; isStaticProperty.value = false; property.value = string.Empty; });

                    // Add separator
                    menu.AddSeparator(string.Empty);

                    string staticName = obj.GetType().Name + "/Static Properties/";

                    // Add Object static members
                    var members = FieldUtility.GetPublicMembers(obj.GetType(), attr.propertyType, true, true, true);
                    if (members.Length > 0)
                    {
                        for (int i = 0; i < members.Length; i++)
                        {
                            var currentMemberName = members[i].Name;
                            menu.AddItem(new GUIContent(staticName + currentMemberName), component == null && currentMemberName == memberName, delegate() { componentProperty.value = null; isStaticProperty.value = true; property.value = currentMemberName; });
                        }
                    }

                    // Add Object members
                    members = FieldUtility.GetPublicMembers(obj.GetType(), attr.propertyType, false, true, true);
                    for (int i = 0; i < members.Length; i++)
                    {
                        var currentMemberName = members[i].Name;
                        menu.AddItem(new GUIContent(obj.GetType().Name + "/" + currentMemberName), component == null && currentMemberName == memberName, delegate() { componentProperty.value = null; isStaticProperty.value = false; property.value = currentMemberName; });
                    }

                    // Add components
                    var gameObject = obj as GameObject;
                    if (gameObject != null)
                    {
                        Component[] components = gameObject.GetComponents <Component>();
                        for (int i = 0; i < components.Length; i++)
                        {
                            // Get the current componet
                            Component currentComponent = components[i];
                            // Get the component type
                            System.Type componentType = currentComponent.GetType();

                            // Get a unique name for the component names
                            string componentName = StringHelper.GetUniqueNameInList(uniqueNames, componentType.Name);
                            uniqueNames.Add(componentName);

                            // Add static members
                            staticName = componentName + "/Static Properties/";
                            members    = FieldUtility.GetPublicMembers(currentComponent.GetType(), attr.propertyType, true, true, true);
                            if (members.Length > 0)
                            {
                                for (int j = 0; j < members.Length; j++)
                                {
                                    var currentMemberName = members[j].Name;
                                    menu.AddItem(new GUIContent(staticName + currentMemberName), currentComponent == component && currentMemberName == memberName, delegate() { componentProperty.value = currentComponent; isStaticProperty.value = true; property.value = currentMemberName; });
                                }
                            }

                            // Get members
                            members = FieldUtility.GetPublicMembers(currentComponent.GetType(), attr.propertyType, false, true, true);

                            // Add members
                            for (int j = 0; j < members.Length; j++)
                            {
                                var currentMemberName = members[j].Name;
                                menu.AddItem(new GUIContent(componentName + "/" + currentMemberName), currentComponent == component && currentMemberName == memberName, delegate() { componentProperty.value = currentComponent; isStaticProperty.value = false; property.value = currentMemberName; });
                            }
                        }
                    }

                    menu.ShowAsContext();
                }

                // Restore olde gui enabled
                GUI.enabled = oldGUIEnabled;

                // Restore label color
                EditorStyles.label.normal.textColor = s_Styles.labelTextColor;
            }
            // Not String
            else
            {
                EditorGUILayout.LabelField(guiContent, new GUIContent("Use UnityObjectReflectProperty with string."));
            }
        }
Exemplo n.º 40
-12
        /// <summary>
        /// Draw the property pop-up.
        /// </summary>
        public override void OnGUI (SerializedNodeProperty property, ActionNode node, GUIContent guiContent) {
            // String
            if (property.propertyType == NodePropertyType.String) {
                var rect = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.popup);
                var id = GUIUtility.GetControlID(FocusType.Passive);
                var popupRect = EditorGUI.PrefixLabel(rect, id, guiContent);
                var popupName = property.value as string ?? string.Empty;
                var propertyOrField = node as PropertyOrField;

                var oldGUIColor = GUI.color;
                if (propertyOrField.propertyType == null)
                    GUI.color = Color.red;

                if (GUI.Button(popupRect, string.IsNullOrEmpty(popupName) ? "None" : popupName, EditorStyles.popup)) {
                    var isSetProperty = propertyOrField is SetProperty;
                    var members = FieldUtility.GetPublicMembers(propertyOrField.targetObject.ObjectType, null, false, isSetProperty, !isSetProperty);
                    var menu = new GenericMenu();

                    // Add none
                    menu.AddItem(new GUIContent("None"), string.IsNullOrEmpty(popupName), delegate () {property.value = string.Empty;});

                    // Add members
                    for (int i = 0; i < members.Length; i++) {
                        var memberName = members[i].Name;
                        menu.AddItem(new GUIContent(memberName), popupName == memberName, delegate () {property.value = memberName;});
                    }

                    menu.ShowAsContext();
                }
                GUI.color = oldGUIColor;
            }
            // Not String
            else
                EditorGUILayout.LabelField(guiContent, new GUIContent("Use UnityObjectProperty with string."));
        }