Ejemplo n.º 1
0
        static private EntityScopeData DoEntityScopeField(GUIContent inLabel, EntityScopeData inScope, RSValidationFlags inFlags, RSValidationContext inContext)
        {
            bool bForceFirst = inFlags.Has(RSValidationFlags.RequireSingleEntity);

            EditorGUILayout.BeginVertical();

            EntityScopeType currentType = inScope.Type;
            EntityScopeType nextType    = ListGUILayout.Popup(inLabel, inScope.Type, RSEditorUtility.s_EntityScopeTypes);

            RSEntityId    entityId      = RSEntityId.Null;
            RSGroupId     groupId       = RSGroupId.Null;
            string        search        = string.Empty;
            bool          useFirst      = bForceFirst;
            string        links         = string.Empty;
            bool          useFirstLinks = bForceFirst;
            RegisterIndex register      = RegisterIndex.Register0;

            using (new EditorGUI.IndentLevelScope())
            {
                switch (currentType)
                {
                case EntityScopeType.ObjectById:
                {
                    entityId = RSEditorUtility.EditorPlugin.EntityIdGUIField(Content.EntityScopeEntityIdLabel, inScope.IdArg, inContext.Manager);
                    if (entityId == RSEntityId.Null && !inFlags.Has(RSValidationFlags.AllowNullEntity))
                    {
                        EditorGUILayout.HelpBox("Null entity not allowed in this context", MessageType.Error);
                    }
                    break;
                }

                case EntityScopeType.ObjectInRegister:
                {
                    if (inFlags.Has(RSValidationFlags.DisallowRegisters))
                    {
                        EditorGUILayout.HelpBox("Local vars not allowed in this context", MessageType.Error);
                    }
                    else
                    {
                        register = inScope.RegisterArg;
                        register = (RegisterIndex)EnumGUILayout.EnumField(Content.EntityScopeRegisterLabel, register);
                    }
                    break;
                }

                case EntityScopeType.ObjectsWithGroup:
                {
                    groupId  = inScope.GroupArg;
                    useFirst = bForceFirst || inScope.UseFirst;

                    using (new EditorGUILayout.HorizontalScope())
                    {
                        groupId = LibraryGUILayout.GroupSelector(Content.EntityScopeGroupLabel, groupId, inContext.Library);
                        using (new EditorGUI.DisabledScope(bForceFirst))
                            using (new RSGUI.LabelWidthScope(100))
                            {
                                useFirst = EditorGUILayout.Toggle(Content.EntityScopeGroupLabel, useFirst, GUILayout.Width(120));
                            }
                    }
                    break;
                }

                case EntityScopeType.ObjectsWithName:
                case EntityScopeType.ObjectsWithPrefab:
                {
                    search   = inScope.SearchArg;
                    useFirst = bForceFirst || inScope.UseFirst;

                    using (new EditorGUILayout.HorizontalScope())
                    {
                        search = EditorGUILayout.TextField(currentType == EntityScopeType.ObjectsWithName ? Content.EntityScopeNameLabel : Content.EntityScopePrefabLabel, search);
                        using (new EditorGUI.DisabledScope(bForceFirst))
                            using (new RSGUI.LabelWidthScope(100))
                            {
                                useFirst = EditorGUILayout.Toggle(Content.EntityScopeUseFirstLabel, useFirst, GUILayout.Width(120));
                            }
                    }
                    break;
                }

                case EntityScopeType.Null:
                {
                    if (!inFlags.Has(RSValidationFlags.AllowNullEntity))
                    {
                        EditorGUILayout.HelpBox("Null entity not allowed in this context", MessageType.Error);
                    }
                    break;
                }

                case EntityScopeType.Invalid:
                {
                    EditorGUILayout.HelpBox("Missing entity not allowed", MessageType.Error);
                    break;
                }

                case EntityScopeType.Global:
                {
                    if (!inFlags.Has(RSValidationFlags.AllowGlobalEntity))
                    {
                        EditorGUILayout.HelpBox("Global entity not allowed in this context", MessageType.Error);
                    }
                    break;
                }

                case EntityScopeType.Argument:
                {
                    if (inContext.Trigger == null)
                    {
                        EditorGUILayout.HelpBox("No argument available: No Trigger", MessageType.Error);
                    }
                    else if (inContext.Trigger.ParameterType == null)
                    {
                        EditorGUILayout.HelpBox(string.Format("No argument available: Trigger {0} has no argument", inContext.Trigger.Name), MessageType.Error);
                    }
                    else if (!inContext.Trigger.ParameterType.Type.CanConvert(RSBuiltInTypes.Entity))
                    {
                        EditorGUILayout.HelpBox(string.Format("No argument available: Trigger {0} has incompatible argument type {1}, which cannot convert to an Entity", inContext.Trigger.Name, inContext.Trigger.ParameterType.Type), MessageType.Error);
                    }
                    break;
                }
                }

                if (inScope.SupportsLinks())
                {
                    links         = inScope.LinksArg;
                    useFirstLinks = bForceFirst || inScope.UseFirstLink;

                    using (new EditorGUILayout.HorizontalScope())
                    {
                        links = EditorGUILayout.TextField(Content.EntityScopeLinksLabel, links);
                        using (new EditorGUI.DisabledScope(bForceFirst))
                            using (new RSGUI.LabelWidthScope(100))
                            {
                                useFirstLinks = EditorGUILayout.Toggle(Content.EntityScopeUseFirstLinkLabel, useFirstLinks, GUILayout.Width(120));
                            }
                    }
                }
            }

            EditorGUILayout.EndVertical();

            switch (nextType)
            {
            case EntityScopeType.Self:
                return(EntityScopeData.Self().WithLinks(links, useFirstLinks));

            case EntityScopeType.Argument:
                return(EntityScopeData.Argument().WithLinks(links, useFirstLinks));

            case EntityScopeType.Global:
                return(EntityScopeData.Global());

            case EntityScopeType.ObjectById:
                return(EntityScopeData.Entity(entityId).WithLinks(links, useFirstLinks));

            case EntityScopeType.ObjectInRegister:
                return(EntityScopeData.Register(register).WithLinks(links, useFirstLinks));

            case EntityScopeType.ObjectsWithGroup:
                return(EntityScopeData.WithGroup(groupId, useFirst).WithLinks(links, useFirstLinks));

            case EntityScopeType.ObjectsWithName:
                return(EntityScopeData.WithName(search, useFirst).WithLinks(links, useFirstLinks));

            case EntityScopeType.ObjectsWithPrefab:
                return(EntityScopeData.WithPrefab(search, useFirst).WithLinks(links, useFirstLinks));

            case EntityScopeType.Invalid:
                return(EntityScopeData.Invalid());

            case EntityScopeType.Null:
            default:
                return(EntityScopeData.Null());
            }
        }
Ejemplo n.º 2
0
        static private void DoResolvableValueData(UndoTarget inUndo, GUIContent inLabel, RSResolvableValueData ioValue, RSTypeInfo inExpectedType, RSValue inDefaultValue, RSValidationFlags inFlags, RSValidationContext inContext)
        {
            EditorGUILayout.BeginVertical();

            bool bDisallowDirectValue = (inExpectedType == null || inExpectedType == RSBuiltInTypes.Any || inFlags.Has(RSValidationFlags.DisallowDirectValue));

            ResolvableValueMode nextMode = ListGUILayout.Popup(inLabel, ioValue.Mode, RSEditorUtility.GetResolvableValueModes(inExpectedType, inFlags, inContext));

            if (nextMode != ioValue.Mode)
            {
                inUndo.MarkDirty("Changed Resolvable Value Mode");
                ioValue.Mode = nextMode;

                switch (nextMode)
                {
                case ResolvableValueMode.Argument:
                    RSResolvableValueData.SetAsArgument(ref ioValue);
                    break;

                case ResolvableValueMode.Query:
                    RSResolvableValueData.SetAsQuery(ref ioValue, new EntityScopedIdentifier(EntityScopeData.Self(), 0));
                    break;

                case ResolvableValueMode.Value:
                    RSResolvableValueData.SetAsValue(ref ioValue, inDefaultValue);
                    break;

                case ResolvableValueMode.Register:
                    RSResolvableValueData.SetAsRegister(ref ioValue, RegisterIndex.Register0);
                    break;
                }
            }

            using (new EditorGUI.IndentLevelScope())
            {
                switch (ioValue.Mode)
                {
                case ResolvableValueMode.Argument:
                {
                    if (inContext.Trigger == null)
                    {
                        EditorGUILayout.HelpBox("No parameter available: No Trigger", MessageType.Error);
                    }
                    else if (inContext.Trigger.ParameterType == null)
                    {
                        EditorGUILayout.HelpBox(string.Format("No parameter available - Trigger {0} has no parameter", inContext.Trigger.Name), MessageType.Error);
                    }
                    else if (inExpectedType != null && !inContext.Trigger.ParameterType.Type.CanConvert(inExpectedType))
                    {
                        EditorGUILayout.HelpBox(string.Format("No parameter available - Trigger {0} has incompatible parameter type {1}, which cannot convert to {2}", inContext.Trigger.Name, inContext.Trigger.ParameterType.Type, inExpectedType), MessageType.Error);
                    }
                    break;
                }

                case ResolvableValueMode.Value:
                {
                    if (bDisallowDirectValue)
                    {
                        EditorGUILayout.HelpBox("Cannot specify a value in this context", MessageType.Error);
                    }
                    else
                    {
                        RSValue nextValue = ValueGUILayout.RSValueField(EditorGUIUtility.TrTempContent(inExpectedType.FriendlyName), ioValue.Value, inExpectedType, inFlags, inContext);
                        if (nextValue != ioValue.Value)
                        {
                            inUndo.MarkDirty("Changed Resolvable Value Value");
                            ioValue.Value = nextValue;
                        }
                    }
                    break;
                }

                case ResolvableValueMode.Register:
                {
                    RegisterIndex nextRegister = (RegisterIndex)EnumGUILayout.EnumField(Content.ResolvableValueRegisterLabel, ioValue.Register);
                    if (nextRegister != ioValue.Register)
                    {
                        inUndo.MarkDirty("Changed Resolvable Value Register");
                        ioValue.Register = nextRegister;
                    }
                    break;
                }

                case ResolvableValueMode.Query:
                {
                    EntityScopedIdentifier query     = ValueGUILayout.QueryField(Content.ResolvableValueQueryLabel, ioValue.Query, inExpectedType, inFlags.ForMethod(true), inContext);
                    RSQueryInfo            queryInfo = inContext.Library.GetQuery(query.Id);
                    if (query != ioValue.Query)
                    {
                        bool bChangedId = query.Id != ioValue.Query.Id;
                        inUndo.MarkDirty("Changed Resolvable Value Query", true);
                        ioValue.Query = query;

                        if (bChangedId)
                        {
                            if (queryInfo == null)
                            {
                                ioValue.QueryArguments = null;
                            }
                            else
                            {
                                queryInfo.PopulateDefaultArguments(ioValue);
                            }
                        }
                    }

                    int currentArgsLength = 0;
                    if (ioValue.QueryArguments != null)
                    {
                        currentArgsLength = ioValue.QueryArguments.Length;
                    }
                    int desiredArgsLength = 0;
                    if (queryInfo != null && queryInfo.Parameters != null)
                    {
                        desiredArgsLength = queryInfo.Parameters.Length;
                    }

                    if (desiredArgsLength == 0 && ioValue.QueryArguments != null)
                    {
                        inUndo.MarkDirtyWithoutUndo("Resizing Arguments", true);
                        ioValue.QueryArguments = null;
                    }
                    else if (desiredArgsLength > 0 && currentArgsLength != desiredArgsLength)
                    {
                        inUndo.MarkDirtyWithoutUndo("Resizing Arguments", true);
                        queryInfo.PopulateDefaultArguments(ioValue, currentArgsLength);
                    }

                    if (ioValue.QueryArguments != null && ioValue.QueryArguments.Length > 0)
                    {
                        using (new EditorGUI.IndentLevelScope())
                        {
                            EditorGUILayout.Space();
                            EditorGUILayout.LabelField(Content.ResolvableValueQueryArgsLabel, RSGUIStyles.SubHeaderStyle);
                            for (int i = 0; i < ioValue.QueryArguments.Length && i < queryInfo.Parameters.Length; ++i)
                            {
                                NestedValue nextValue = ValueGUILayout.NestedParameterField(queryInfo.Parameters[i], ioValue.QueryArguments[i], inFlags, inContext);
                                if (nextValue != ioValue.QueryArguments[i])
                                {
                                    inUndo.MarkDirty("Changed Resolvable Value Query Argument");
                                    ioValue.QueryArguments[i] = nextValue;
                                }
                            }
                        }
                    }

                    break;
                }
                }
            }

            EditorGUILayout.EndVertical();
        }
Ejemplo n.º 3
0
        static private NestedValue DoNestedValueField(GUIContent inLabel, NestedValue inValue, RSTypeInfo inExpectedType, RSValue inDefaultValue, RSValidationFlags inFlags, RSValidationContext inContext)
        {
            EditorGUILayout.BeginVertical();
            ResolvableValueMode nextType = ListGUILayout.Popup(inLabel, inValue.Mode, RSEditorUtility.GetResolvableValueModes(inExpectedType, inFlags, inContext));

            RSValue value = inDefaultValue;
            EntityScopedIdentifier query    = new EntityScopedIdentifier(EntityScopeData.Self(), 0);
            RegisterIndex          register = RegisterIndex.Register0;

            using (new EditorGUI.IndentLevelScope())
            {
                switch (inValue.Mode)
                {
                case ResolvableValueMode.Argument:
                {
                    if (inContext.Trigger == null)
                    {
                        EditorGUILayout.HelpBox("No parameter available: No Trigger", MessageType.Error);
                    }
                    else if (inContext.Trigger.ParameterType == null)
                    {
                        EditorGUILayout.HelpBox(string.Format("No parameter available - Trigger {0} has no parameter", inContext.Trigger.Name), MessageType.Error);
                    }
                    else if (inExpectedType != null && !inContext.Trigger.ParameterType.Type.CanConvert(inExpectedType))
                    {
                        EditorGUILayout.HelpBox(string.Format("No parameter available - Trigger {0} has incompatible parameter type {1}, which cannot convert to {2}", inContext.Trigger.Name, inContext.Trigger.ParameterType.Type, inExpectedType), MessageType.Error);
                    }
                    break;
                }

                case ResolvableValueMode.Value:
                {
                    if (inExpectedType == null || inExpectedType == RSBuiltInTypes.Any || inFlags.Has(RSValidationFlags.DisallowDirectValue))
                    {
                        EditorGUILayout.HelpBox("Cannot specify a value in this context", MessageType.Error);
                    }
                    else
                    {
                        value = RSValueField(EditorGUIUtility.TrTempContent(inExpectedType.FriendlyName), inValue.Value, inExpectedType, inFlags, inContext);
                    }
                    break;
                }

                case ResolvableValueMode.Query:
                {
                    query = ValueGUILayout.QueryField(RuleGUILayout.Content.ResolvableValueQueryLabel, inValue.Query, inExpectedType, inFlags.ForMethod(false), inContext);
                    break;
                }

                case ResolvableValueMode.Register:
                {
                    register = (RegisterIndex)EnumGUILayout.EnumField(RuleGUILayout.Content.ResolvableValueRegisterLabel, inValue.Register);
                    break;
                }
                }
            }

            EditorGUILayout.EndVertical();

            switch (nextType)
            {
            case ResolvableValueMode.Argument:
                return(NestedValue.FromArgument());

            case ResolvableValueMode.Query:
                return(NestedValue.FromQuery(query));

            case ResolvableValueMode.Register:
                return(NestedValue.FromRegister(register));

            case ResolvableValueMode.Value:
            default:
                return(NestedValue.FromValue(value));
            }
        }