/// <summary> /// Renders a layout editor for an EntityScopeData. /// </summary> static public EntityScopeData EntityScopeField(EntityScopeData inScope, RSValidationFlags inFlags, RSValidationContext inContext) { using (new RSGUI.LabelWidthScope(0)) { return(DoEntityScopeField(GUIContent.none, inScope, inFlags, inContext)); } }
static private void ValidateValue(RSValue inValue, RSTypeInfo inExpectedType, RSValidationFlags inFlags, RSValidationState ioState, RSValidationContext inContext) { Type systemType = inExpectedType.SystemType; if (systemType.IsEnum) { try { Enum currentValue = inValue.AsEnum(); } catch (Exception e) { Debug.LogException(e); ioState.Error("Enum {0} cannot be represented as type {1}", inValue, inExpectedType); } return; } if (inExpectedType == RSBuiltInTypes.Entity) { EntityScopeData scope = inValue.AsEntity; ValidateEntityScope(scope, inFlags.ForEntityValue(), ioState, inContext); } else if (inExpectedType == RSBuiltInTypes.GroupId) { RSGroupId group = inValue.AsGroupId; ValidateGroupId(group, inFlags, ioState, inContext); } else if (inExpectedType == RSBuiltInTypes.TriggerId) { RSTriggerId triggerId = inValue.AsTriggerId; ValidateTriggerId(triggerId, inFlags, ioState, inContext); } }
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(); }
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 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)); }
/// <summary> /// Renders a layout editor for an EntityScopeData. /// </summary> static public EntityScopeData EntityScopeField(GUIContent inLabel, EntityScopeData inScope, RSValidationFlags inFlags, RSValidationContext inContext) { return(DoEntityScopeField(inLabel, inScope, inFlags, inContext)); }
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)); } }
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 void ValidateEntityScope(EntityScopeData inScope, RSValidationFlags inFlags, RSValidationState ioState, RSValidationContext inContext) { bool bForceFirst = inFlags.Has(RSValidationFlags.RequireSingleEntity); switch (inScope.Type) { case EntityScopeType.ObjectById: { RSEntityId entityId = inScope.IdArg; ValidateEntityId(entityId, inFlags, ioState, inContext); break; } case EntityScopeType.ObjectsWithGroup: { if (bForceFirst && !inScope.UseFirst) { ioState.Error("Potentially multiple return values in context where only one value is accepted"); } ValidateGroupId(inScope.GroupArg, inFlags, ioState, inContext); break; } case EntityScopeType.ObjectsWithName: case EntityScopeType.ObjectsWithPrefab: { if (bForceFirst && !inScope.UseFirst) { ioState.Error("Potentially multiple return values in context where only one value is accepted"); } string name = inScope.SearchArg; if (string.IsNullOrEmpty(name)) { ioState.Warn("Empty search string"); } break; } case EntityScopeType.Null: { if (!inFlags.Has(RSValidationFlags.AllowNullEntity)) { ioState.Error("Null entity not allowed in this context"); } break; } case EntityScopeType.Invalid: { ioState.Error("Missing entity"); break; } case EntityScopeType.Global: { if (!inFlags.Has(RSValidationFlags.AllowGlobalEntity)) { ioState.Error("Global entity not allowed in this context"); } break; } case EntityScopeType.Argument: { ValidateTriggerArgument(RSBuiltInTypes.Entity, inFlags, ioState, inContext); break; } } }
/// <summary> /// Converts a C# object to an RSValue. /// </summary> static public RSValue ToRSValue(object inObject) { if (inObject == null) { return(RSValue.Null); } Type objType = inObject.GetType(); if (objType == typeof(RSValue)) { return((RSValue)inObject); } if (objType.IsEnum) { return(RSValue.FromEnum((Enum)inObject)); } switch (Type.GetTypeCode(objType)) { case TypeCode.Boolean: return(RSValue.FromBool((bool)inObject)); case TypeCode.Byte: return(RSValue.FromInt((byte)inObject)); case TypeCode.Char: return(RSValue.FromInt((char)inObject)); case TypeCode.Double: Log.Warn("[RSInterop] Truncation from Double to Single"); return(RSValue.FromFloat((float)(double)inObject)); case TypeCode.Int16: return(RSValue.FromInt((Int16)inObject)); case TypeCode.Int32: return(RSValue.FromInt((Int32)inObject)); case TypeCode.SByte: return(RSValue.FromInt((sbyte)inObject)); case TypeCode.Single: return(RSValue.FromFloat((float)inObject)); case TypeCode.String: return(RSValue.FromString((string)inObject)); case TypeCode.UInt16: return(RSValue.FromInt((UInt16)inObject)); case TypeCode.UInt32: Log.Warn("[RSInterop] Truncation from UInt32 to Int32"); return(RSValue.FromInt((int)(UInt32)inObject)); case TypeCode.UInt64: Log.Warn("[RSInterop] Truncation from UInt64 to Int32"); return(RSValue.FromInt((int)(UInt64)inObject)); case TypeCode.Object: { if (objType == typeof(Color)) { return(RSValue.FromColor((Color)inObject)); } if (objType == typeof(Vector2)) { return(RSValue.FromVector2((Vector2)inObject)); } if (objType == typeof(Vector3)) { return(RSValue.FromVector3((Vector3)inObject)); } if (objType == typeof(Vector4)) { return(RSValue.FromVector4((Vector4)inObject)); } if (objType == typeof(RSGroupId)) { return(RSValue.FromGroupId((RSGroupId)inObject)); } if (objType == typeof(RSTriggerId)) { return(RSValue.FromTriggerId((RSTriggerId)inObject)); } if (typeof(IRSEntity).IsAssignableFrom(objType)) { IRSEntity entity = (IRSEntity)inObject; EntityScopeData scope = EntityScopeData.Entity(entity.Id); return(RSValue.FromEntity(scope)); } break; } } throw new ArgumentException(string.Format("Unable to convert object of type {0} to RSValue", objType.Name), "inObject"); }
/// <summary> /// Resolves scope to an entity or set of entities. /// </summary> public MultiReturn <IRSRuntimeEntity> ResolveEntity(EntityScopeData inScope) { MultiReturn <IRSRuntimeEntity> returnVal; switch (inScope.Type) { case EntityScopeType.Null: { returnVal = MultiReturn <IRSRuntimeEntity> .Default; break; } case EntityScopeType.Self: { returnVal = new MultiReturn <IRSRuntimeEntity>(m_Self); break; } case EntityScopeType.Global: { return(new MultiReturn <IRSRuntimeEntity>()); } case EntityScopeType.Argument: { returnVal = ResolveEntity(m_Argument.AsEntity); break; } case EntityScopeType.ObjectById: { returnVal = new MultiReturn <IRSRuntimeEntity>(m_Environment.Entities.Lookup.EntityWithId(inScope.IdArg)); break; } case EntityScopeType.ObjectInRegister: { EntityScopeData id = PeekRegister(inScope.RegisterArg).AsEntity; returnVal = new MultiReturn <IRSRuntimeEntity>(m_Environment.Entities.Lookup.EntityWithId(id.IdArg)); break; } case EntityScopeType.ObjectsWithGroup: { if (inScope.UseFirst) { returnVal = new MultiReturn <IRSRuntimeEntity>(m_Environment.Entities.Lookup.EntityWithGroup(inScope.GroupArg)); } else { returnVal = new MultiReturn <IRSRuntimeEntity>(m_Environment.Entities.Lookup.EntitiesWithGroup(inScope.GroupArg)); } break; } case EntityScopeType.ObjectsWithName: { if (inScope.UseFirst) { returnVal = new MultiReturn <IRSRuntimeEntity>(m_Environment.Entities.Lookup.EntityWithName(inScope.SearchArg)); } else { returnVal = new MultiReturn <IRSRuntimeEntity>(m_Environment.Entities.Lookup.EntitiesWithName(inScope.SearchArg)); } break; } case EntityScopeType.ObjectsWithPrefab: { if (inScope.UseFirst) { returnVal = new MultiReturn <IRSRuntimeEntity>(m_Environment.Entities.Lookup.EntityWithPrefab(inScope.SearchArg)); } else { returnVal = new MultiReturn <IRSRuntimeEntity>(m_Environment.Entities.Lookup.EntitiesWithPrefab(inScope.SearchArg)); } break; } case EntityScopeType.Invalid: { Assert.Fail("Missing entity reference"); return(MultiReturn <IRSRuntimeEntity> .Default); } default: { Assert.Fail("Unrecognized scope type {0}", inScope.Type); return(MultiReturn <IRSRuntimeEntity> .Default); } } return(ResolveEntityLinks(returnVal, inScope.LinksArg, inScope.UseFirstLink)); }