/// <summary> /// Renders a layout editor for an RSValue. /// </summary> static public RSValue RSValueField(RSValue inValue, RSTypeInfo inExpectedType, RSValidationFlags inFlags, RSValidationContext inContext) { using (new RSGUI.LabelWidthScope(0)) { return(DoRSValueField(GUIContent.none, inValue, inExpectedType, 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); } }
internal ExecutionScope CreateScope(IRSRuntimeEntity inEntity, RSValue inArgument, RuleFlags inFlags) { List <ExecutionScope> pool; if ((inFlags & RuleFlags.UsesRegisters) != 0) { pool = m_RegisterScopePool; } else { pool = m_LocalScopePool; } ExecutionScope scope; int count = pool.Count; if (count > 0) { scope = pool[count - 1]; pool.RemoveAt(count - 1); } else { scope = ConstructScope(inFlags); } scope.Initialize(inEntity, inArgument); return(scope); }
internal void Broadcast(RSTriggerId inTriggerId, RSValue inArgument, bool inbForce) { foreach (var entity in Entities.EntitiesForTrigger(inTriggerId)) { TriggerRS(entity, inTriggerId, inArgument, inbForce); } }
internal RSTypeInfo(Type inType, string inFriendlyName, RSValue inDefault, TypeFlags inFlags = 0) { SystemType = inType; FriendlyName = inFriendlyName ?? inType.Name; DefaultValue = inDefault; Flags = inFlags | GetFlags(inType); }
internal void Persist(IRSRuntimeComponent inComponent, int inFlags, ref RSPersistComponentData outData) { if (outData == null) { outData = new RSPersistComponentData(); } outData.ComponentType = IdHash; if (m_PersistFields != null) { Array.Resize(ref outData.NamedValues, m_PersistFields.Count); int idx = 0; foreach (var persistField in m_PersistFields.Values) { string name = persistField.Name; RSValue value = persistField.Persist(inComponent); outData.NamedValues[idx++] = new RSNamedValue(name, value); } } if (m_UseCustomDataField) { ((IRSCustomPersistDataProvider)inComponent).GetCustomPersistData(ref outData.CustomData, inFlags); } }
/// <summary> /// Evaluates a condition. /// </summary> public bool EvaluateCondition(RSConditionData inCondition) { Assert.True(!inCondition.Target.IsMultiValue(), "Multi-target queries cannot be right-hand values for conditions"); MultiReturn <RSValue> query = ResolveValue(inCondition.Query); RSValue target = ResolveValue(inCondition.Target).ForceSingle(); CompareOperator op = inCondition.Operator; if (query.Set != null) { Subset subset = inCondition.MultiQuerySubset; foreach (var check in query.Set) { bool bPass = Evaluate(op, check, target); switch (subset) { case Subset.All: { if (!bPass) { return(false); } break; } case Subset.Any: { if (bPass) { return(true); } break; } case Subset.None: { if (bPass) { return(false); } break; } } } switch (subset) { case Subset.All: case Subset.None: return(true); default: return(false); } } return(Evaluate(op, query.Single, target)); }
static internal RSValue[] Convert(params object[] inValues) { RSValue[] converted = new RSValue[inValues.Length]; for (int i = 0; i < inValues.Length; ++i) { converted[i] = RSInterop.ToRSValue(inValues[i]); } return(converted); }
internal override void Link(RSTypeAssembly inAssembly) { m_MethodSettings.Configure(m_MethodInfo, m_Parameters, true); OwnerType = m_MethodSettings.BoundType; ReturnType = RSInterop.RSTypeFor(m_MethodInfo.ReturnType, inAssembly); m_DefaultValue = m_DefaultSystemValue != null?RSInterop.ToRSValue(m_DefaultSystemValue) : ReturnType.DefaultValue; GenerateParameters(inAssembly); }
private bool TryCreateMeta(Type inType, out RSTypeInfo outMetadata) { if (inType.IsEnum) { Enum defaultVal = (Enum)Enum.ToObject(inType, 0); outMetadata = new RSTypeInfo(inType, null, RSValue.FromEnum(defaultVal)); outMetadata.InitializeEnum(); return(true); } outMetadata = null; return(false); }
public void Reset() { m_Self = null; m_Argument = RSValue.Null; if (m_Registers != null) { for (int i = 0; i < RSRegisters.MaxRegisters; ++i) { m_Registers[i] = default(RSValue); } } }
internal void TriggerRS(IRSRuntimeEntity inEntity, RSTriggerId inTriggerId, RSValue inArgument, bool inbForce) { if (!inbForce && inEntity.IsLocked()) { return; } ExecutionScope scope = CreateScope(inEntity, inArgument, 0); using (new SharedRef <ExecutionScope>(scope)) { inEntity?.RuleTable?.EvaluateTrigger(inTriggerId, scope); } }
public bool Evaluate(CompareOperator inComparison, RSValue inCheck, RSValue inValue) { switch (inCheck.GetInnerType()) { case RSValue.InnerType.Null: return(ComparisonExtensions.Evaluate(inComparison, false, inCheck.GetInnerType() != RSValue.InnerType.Null)); case RSValue.InnerType.Int32: return(ComparisonExtensions.Evaluate(inComparison, inCheck.AsInt, inValue.AsInt)); case RSValue.InnerType.Bool: return(ComparisonExtensions.Evaluate(inComparison, inCheck.AsBool, inValue.AsBool)); case RSValue.InnerType.Color: return(ComparisonExtensions.EvaluateEquatable(inComparison, inCheck.AsColor, inValue.AsColor)); case RSValue.InnerType.Float: return(ComparisonExtensions.Evaluate(inComparison, inCheck.AsFloat, inValue.AsFloat)); case RSValue.InnerType.Vector2: return(ComparisonExtensions.EvaluateEquatable(inComparison, inCheck.AsVector2, inValue.AsVector2)); case RSValue.InnerType.Vector3: return(ComparisonExtensions.EvaluateEquatable(inComparison, inCheck.AsVector3, inValue.AsVector3)); case RSValue.InnerType.Vector4: return(ComparisonExtensions.EvaluateEquatable(inComparison, inCheck.AsVector4, inValue.AsVector4)); case RSValue.InnerType.String: return(ComparisonExtensions.Evaluate(inComparison, inCheck.AsString, inValue.AsString)); case RSValue.InnerType.Enum: return(ComparisonExtensions.Evaluate(inComparison, inCheck.AsInt, inValue.AsInt)); case RSValue.InnerType.EntityScope: return(ComparisonExtensions.EvaluateReferenceEquals(inComparison, ResolveEntity(inCheck.AsEntity).ForceSingle(), ResolveEntity(inValue.AsEntity).ForceSingle())); default: throw new ArgumentException("Invalid value type " + inCheck.GetInnerType(), "inCheck"); } }
internal void Restore(IRSRuntimeComponent inComponent, RSPersistComponentData inData, RSEnvironment inEnvironment, int inFlags) { if (inData.NamedValues != null) { for (int i = 0; i < inData.NamedValues.Length; ++i) { string name = inData.NamedValues[i].Name; RSValue value = inData.NamedValues[i].Value; RSPersistFieldInfo fieldInfo; m_PersistFields.TryGetValue(name, out fieldInfo); if (fieldInfo != null) { fieldInfo.Restore(inComponent, value, inEnvironment); } } } if (m_UseCustomDataField) { ((IRSCustomPersistDataProvider)inComponent).RestoreCustomPersistData(inData.CustomData, inFlags, inEnvironment); } }
/// <summary> /// Renders a layout editor for a NestedValue. /// </summary> static public NestedValue NestedValueField(GUIContent inLabel, NestedValue inValue, RSTypeInfo inExpectedType, RSValue inDefaultValue, RSValidationFlags inFlags, RSValidationContext inContext) { return(DoNestedValueField(inLabel, inValue, inExpectedType, inDefaultValue, 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)); } }
public void LoadRegister(RegisterIndex inRegister, RSValue inValue) { Assert.True(m_Registers != null, "Execution Scope has no registers available"); m_Registers[(int)inRegister] = inValue; }
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); }
/// <summary> /// Renders a layout editor for an RSValue. /// </summary> static public RSValue RSValueField(GUIContent inLabel, RSValue inValue, RSTypeInfo inExpectedType, RSValidationFlags inFlags, RSValidationContext inContext) { return(DoRSValueField(inLabel, inValue, inExpectedType, inFlags, inContext)); }
public void Initialize(IRSRuntimeEntity inSelf, RSValue inArgument) { m_Self = inSelf; m_Argument = inArgument; }
/// <summary> /// Retrieves the type metadata for the given value. /// </summary> static public RSTypeInfo RSTypeFor(RSValue inValue, RSTypeAssembly inAssembly) { return(RSTypeFor(inValue.GetInteropType(), inAssembly)); }
/// <summary> /// Converts an RSValue to the given C# type. /// </summary> static public object ToObject(Type inType, RSValue inValue, ExecutionScope inContext) { if (inType == null || inType == typeof(void)) { return(null); } if (inType == typeof(object)) { return(inValue); } if (inType == typeof(RSValue)) { return(inValue); } if (inType.IsEnum) { return(inValue.AsEnum(inType)); } switch (Type.GetTypeCode(inType)) { case TypeCode.Boolean: return(inValue.AsBool); case TypeCode.Byte: return((byte)inValue.AsInt); case TypeCode.Char: return((char)inValue.AsInt); case TypeCode.Double: return((double)inValue.AsFloat); case TypeCode.Int16: return((Int16)inValue.AsInt); case TypeCode.Int32: return(inValue.AsInt); case TypeCode.Int64: return((Int64)inValue.AsInt); case TypeCode.SByte: return((sbyte)inValue.AsInt); case TypeCode.Single: return(inValue.AsFloat); case TypeCode.String: return(inValue.AsString); case TypeCode.UInt16: return((UInt16)inValue.AsInt); case TypeCode.UInt32: return((UInt32)inValue.AsInt); case TypeCode.UInt64: return((UInt64)inValue.AsInt); case TypeCode.Object: { if (inType == typeof(Color)) { return(inValue.AsColor);; } if (inType == typeof(Vector2)) { return(inValue.AsVector2); } if (inType == typeof(Vector3)) { return(inValue.AsVector3); } if (inType == typeof(Vector4)) { return(inValue.AsVector4); } if (inType == typeof(RSGroupId)) { return(inValue.AsGroupId); } if (inType == typeof(RSTriggerId)) { return(inValue.AsTriggerId); } if (typeof(IRSEntity).IsAssignableFrom(inType)) { return(inContext.ResolveEntity(inValue.AsEntity).ForceSingle()); } break; } } throw new ArgumentException(string.Format("Unable to convert RSValue {0} to object of type {1}", inValue, inType), "inValue"); }
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(); }
/// <summary> /// Renders a layout editor for a ResolvableValue. /// </summary> static public void ResolvableValueData(UndoTarget inUndo, GUIContent inLabel, RSResolvableValueData ioValue, RSTypeInfo inExpectedType, RSValue inDefaultValue, RSValidationFlags inFlags, RSValidationContext inContext) { DoResolvableValueData(inUndo, inLabel, ioValue, inExpectedType, inDefaultValue, inFlags, inContext); }
/// <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"); }
static private void LoadRegister(IScriptContext inContext, [RSParameter("Register")] RegisterIndex inRegister, [RSParameter("Value")] RSValue inValue) { inContext?.Logger?.Log("Loading register {0} with value {1}", inRegister, inValue); inContext.LoadRegister(inRegister, inValue); }
/// <summary> /// Converts an RSValue to the given C# type. /// </summary> static public T ToObject <T>(RSValue inValue, ExecutionScope inContext) { return((T)ToObject(typeof(T), inValue, inContext)); }
/// <summary> /// Converts an RSValue to its closest mapped C# type. /// </summary> static public object ToObject(RSValue inValue, ExecutionScope inContext) { return(ToObject(inValue.GetInteropType(), inValue, inContext)); }
internal void Restore(IRSRuntimeComponent inComponent, RSValue inValue, RSEnvironment inEnvironment) { object restoreValue = RSInterop.ToObject(m_FieldType, inValue, inEnvironment.StaticScope); m_FieldInfo.SetValue(inComponent, restoreValue); }