/// <summary>
/// Renders editor for rule info. Does not include conditions or actions.
/// </summary>
static public void RuleData(UndoTarget inUndo, RSRuleData ioRule, RSRuleTableData ioTable, RSValidationFlags inFlags, RSValidationContext inContext)
{
string preview = ioRule.GetPreviewString(null, inContext.Library);
GUILayout.Label(preview, RSGUIStyles.RuleHeaderStyle);
EditorGUILayout.Space();
string newName = EditorGUILayout.TextField(Content.RuleNameLabel, ioRule.Name);
if (newName != ioRule.Name)
{
inUndo.MarkDirty("Changed Rule Name");
ioRule.Name = newName;
}
RSTriggerId newTriggerId;
if (inFlags.Has(RSValidationFlags.FilterSelection) && inContext.Entity != null)
{
newTriggerId = LibraryGUILayout.TriggerSelector(Content.RuleTriggerLabel, ioRule.TriggerId, inContext.Entity, inContext.Library);
}
else
{
newTriggerId = LibraryGUILayout.TriggerSelector(Content.RuleTriggerLabel, ioRule.TriggerId, inContext.Library);
}
if (newTriggerId != ioRule.TriggerId)
{
inUndo.MarkDirty("Changed Rule Trigger", true);
ioRule.TriggerId = newTriggerId;
TableUtils.UpdateUniqueRuleTriggers(ioTable);
}
if (newTriggerId != RSTriggerId.Null)
{
RSTriggerInfo info = inContext.Library.GetTrigger(newTriggerId);
if (info != null && info.ParameterType != null)
{
using (new EditorGUI.IndentLevelScope())
{
EditorGUILayout.LabelField(Content.RuleParameterLabel, EditorGUIUtility.TrTextContent(info.ParameterType.ToStringWithoutDefault(), info.ParameterType.Tooltip));
}
}
}
EditorGUILayout.Space();
// Enabled
bool bEnabled = EditorGUILayout.Toggle(Content.RuleEnabledLabel, ioRule.Enabled);
if (bEnabled != ioRule.Enabled)
{
inUndo.MarkDirty("Changed Rule Enabled");
ioRule.Enabled = bEnabled;
}
bool bOnlyOnce = EditorGUILayout.Toggle(Content.RuleOnlyOnceLabel, ioRule.OnlyOnce);
if (bOnlyOnce != ioRule.OnlyOnce)
{
inUndo.MarkDirty("Changed Rule OnlyOnce");
ioRule.OnlyOnce = bOnlyOnce;
}
bool bDontInterrupt = EditorGUILayout.Toggle(Content.RuleDontInterruptLabel, ioRule.DontInterrupt);
if (bDontInterrupt != ioRule.DontInterrupt)
{
inUndo.MarkDirty("Changed Rule DontInterrupt");
ioRule.DontInterrupt = bDontInterrupt;
}
EditorGUILayout.Space();
string newGroup = EditorGUILayout.TextField(Content.RuleGroupLabel, ioRule.RoutineGroup);
if (newGroup != ioRule.RoutineGroup)
{
inUndo.MarkDirty("Changed Rule Group");
ioRule.RoutineGroup = newGroup;
}
}
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());
}
}
static private RSValue DoRSValueField(GUIContent inLabel, RSValue inValue, RSTypeInfo inExpectedType, RSValidationFlags inFlags, RSValidationContext inContext)
{
Type systemType = inExpectedType.SystemType;
if (systemType.IsEnum)
{
Enum currentValue;
try
{
currentValue = inValue.AsEnum();
}
catch (Exception e)
{
Debug.LogException(e);
currentValue = inExpectedType.DefaultValue.AsEnum();
}
Enum nextValue = EnumGUILayout.EnumField(inLabel, currentValue);
return(RSValue.FromEnum(nextValue));
}
if (inExpectedType == RSBuiltInTypes.Int)
{
int currentValue = inValue.AsInt;
int nextValue = EditorGUILayout.DelayedIntField(inLabel, currentValue);
return(RSValue.FromInt(nextValue));
}
else if (inExpectedType == RSBuiltInTypes.Float)
{
float currentValue = inValue.AsFloat;
float nextValue = EditorGUILayout.DelayedFloatField(inLabel, currentValue);
return(RSValue.FromFloat(nextValue));
}
else if (inExpectedType == RSBuiltInTypes.Bool)
{
bool currentValue = inValue.AsBool;
bool nextValue = EditorGUILayout.Toggle(inLabel, currentValue);
return(RSValue.FromBool(nextValue));
}
else if (inExpectedType == RSBuiltInTypes.Color)
{
Color currentValue = inValue.AsColor;
Color nextValue = EditorGUILayout.ColorField(inLabel, currentValue);
return(RSValue.FromColor(nextValue));
}
else if (inExpectedType == RSBuiltInTypes.String)
{
string currentValue = inValue.AsString;
string nextValue = EditorGUILayout.TextField(inLabel, currentValue);
return(RSValue.FromString(nextValue));
}
else if (inExpectedType == RSBuiltInTypes.Vector2)
{
Vector2 currentValue = inValue.AsVector2;
Vector2 nextValue = EditorGUILayout.Vector2Field(inLabel, currentValue);
return(RSValue.FromVector2(nextValue));
}
else if (inExpectedType == RSBuiltInTypes.Vector3)
{
Vector3 currentValue = inValue.AsVector3;
Vector3 nextValue = EditorGUILayout.Vector3Field(inLabel, currentValue);
return(RSValue.FromVector3(nextValue));
}
else if (inExpectedType == RSBuiltInTypes.Vector4)
{
Vector4 currentValue = inValue.AsVector4;
Vector4 nextValue = EditorGUILayout.Vector4Field(inLabel, currentValue);
return(RSValue.FromVector4(nextValue));
}
else if (inExpectedType == RSBuiltInTypes.Entity)
{
EntityScopeData currentValue = inValue.AsEntity;
EntityScopeData nextValue = EntityScopeField(inLabel, currentValue, inFlags.ForEntityValue(), inContext);
return(RSValue.FromEntity(nextValue));
}
else if (inExpectedType == RSBuiltInTypes.GroupId)
{
RSGroupId currentValue = inValue.AsGroupId;
RSGroupId nextValue = LibraryGUILayout.GroupSelector(inLabel, currentValue, inContext.Library);
return(RSValue.FromGroupId(nextValue));
}
else if (inExpectedType == RSBuiltInTypes.TriggerId)
{
RSTriggerId currentValue = inValue.AsTriggerId;
RSTypeInfo restrictTriggerType = inContext.Parameter?.TriggerParameterType;
RSTriggerId nextValue;
if (restrictTriggerType != null)
{
nextValue = LibraryGUILayout.TriggerSelector(inLabel, currentValue, restrictTriggerType, inContext.Library);
}
else
{
nextValue = LibraryGUILayout.TriggerSelector(inLabel, currentValue, inContext.Library);
}
return(RSValue.FromTriggerId(nextValue));
}
else
{
EditorGUILayout.HelpBox(string.Format("Unable to display editor for type {0}", inExpectedType), MessageType.Error);
}
return(inValue);
}
static private EntityScopedIdentifier DoActionField(GUIContent inLabel, EntityScopedIdentifier inIdentifier, RSValidationFlags inFlags, RSValidationContext inContext)
{
EntityScopeData scope = inIdentifier.Scope;
int actionId = inIdentifier.Id;
using (new EditorGUILayout.VerticalScope())
{
scope = EntityScopeField(inLabel, scope, inFlags.ForMethodScope(), inContext);
using (new EditorGUI.IndentLevelScope())
{
switch (scope.Type)
{
case EntityScopeType.Global:
actionId = LibraryGUILayout.ActionSelectorGlobal(Content.ActionIdLabel, actionId, inContext.Library);
break;
case EntityScopeType.Null:
EditorGUILayout.HelpBox("Cannot perform action on null entity", MessageType.Error);
break;
case EntityScopeType.Invalid:
EditorGUILayout.HelpBox("Cannot perform action on missing entity", MessageType.Error);
break;
case EntityScopeType.Self:
{
if (inFlags.Has(RSValidationFlags.FilterSelection) && !scope.HasLinks() && inContext.Entity != null)
{
actionId = LibraryGUILayout.ActionSelector(Content.ActionIdLabel, actionId, inContext.Entity, inContext.Library);
}
else
{
actionId = LibraryGUILayout.ActionSelectorUnknown(Content.ActionIdLabel, actionId, inContext.Library);
}
break;
}
case EntityScopeType.ObjectById:
{
RSEntityId entityId = scope.IdArg;
IRSEntity entity = null;
if (inFlags.Has(RSValidationFlags.FilterSelection) && entityId != RSEntityId.Null && !scope.HasLinks() && inContext.Manager != null && (entity = inContext.Manager.Lookup.EntityWithId(entityId)) != null)
{
actionId = LibraryGUILayout.ActionSelector(Content.ActionIdLabel, actionId, entity, inContext.Library);
}
else
{
actionId = LibraryGUILayout.ActionSelectorUnknown(Content.ActionIdLabel, actionId, inContext.Library);
}
break;
}
default:
actionId = LibraryGUILayout.ActionSelectorUnknown(Content.ActionIdLabel, actionId, inContext.Library);
break;
}
if (actionId == 0)
{
EditorGUILayout.HelpBox("Cannot perform null action", MessageType.Error);
}
}
}
return(new EntityScopedIdentifier(scope, actionId));
}
private void TableParamsGUI()
{
{
TableMode nextMode = (TableMode)EnumGUILayout.EnumField("Search Type", m_Params.TableParams.Mode);
if (nextMode != m_Params.TableParams.Mode)
{
m_SelfUndoTarget.MarkDirty("Switched entity search mode");
m_Params.TableParams.Mode = nextMode;
m_Params.TableParams.Clear();
m_SearchQueued = true;
}
}
switch (m_Params.TableParams.Mode)
{
case TableMode.Action:
{
int nextAction = LibraryGUILayout.ActionSelector(s_ActionLabel, m_Params.TableParams.ElementSearchId, m_Library);
if (nextAction != m_Params.TableParams.ElementSearchId)
{
m_SelfUndoTarget.MarkDirty("Changed action id");
m_Params.TableParams.ElementSearchId = nextAction;
m_SearchQueued = true;
}
break;
}
case TableMode.Query:
{
int nextQuery = LibraryGUILayout.QuerySelector(s_QueryLabel, m_Params.TableParams.ElementSearchId, false, m_Library);
if (nextQuery != m_Params.TableParams.ElementSearchId)
{
m_SelfUndoTarget.MarkDirty("Changed query id");
m_Params.TableParams.ElementSearchId = nextQuery;
m_SearchQueued = true;
}
break;
}
case TableMode.Trigger:
{
int nextTrigger = (int)LibraryGUILayout.TriggerSelector(s_TriggerLabel, new RSTriggerId(m_Params.TableParams.ElementSearchId), m_Library);
if (nextTrigger != m_Params.TableParams.ElementSearchId)
{
m_SelfUndoTarget.MarkDirty("Changed trigger id");
m_Params.TableParams.ElementSearchId = nextTrigger;
m_SearchQueued = true;
}
break;
}
case TableMode.Entity:
{
RSEntityId entityId = RSEditorUtility.EditorPlugin.EntityIdGUIField(s_EntityLabel, m_Params.TableParams.EntitySearch, m_EntityMgr);
if (entityId != m_Params.TableParams.EntitySearch)
{
m_SelfUndoTarget.MarkDirty("Changed entity search");
m_Params.TableParams.EntitySearch = entityId;
m_SearchQueued = true;
}
break;
}
case TableMode.String:
{
string nextString = EditorGUILayout.TextField("Search", m_Params.TableParams.StringSearch);
if (nextString != m_Params.TableParams.StringSearch)
{
m_SelfUndoTarget.MarkDirty("Changed string search");
m_Params.TableParams.StringSearch = nextString;
m_SearchQueued = true;
}
break;
}
}
}
