public override void GetInputs(IList <VariableDefinition> inputs, string source) { if (Left is IdentifierOperation leftIdentifier && leftIdentifier.Name == source) { inputs.Add(new VariableDefinition { Name = _rightIdentifier.Name, Definition = ValueDefinition.Create(VariableType.Empty) }); }
public override void GetOutputs(IList <VariableDefinition> outputs) { if (InstructionStore.IsOutput(EffectVariable)) { outputs.Add(new VariableDefinition { Name = EffectVariable.RootName, Definition = ValueDefinition.Create <GameObject>() }); } }
public void ChangeDefinition(int index, ValueDefinition definition) { var variable = Variables[index]; if (!definition.IsValid(variable)) { Variables[index] = definition.Generate(null); } Definitions[index] = definition; }
public SetVariableResult SetVariable(int index, VariableValue value) { var name = Names[index]; var result = SetVariable(name, value); if (result == SetVariableResult.Success && value.Type != Definitions[index].Type) { Definitions[index] = ValueDefinition.Create(value.Type, null, null, null, false, false); } return(result); }
public bool AddDefinition(string name, VariableType type) { if (string.IsNullOrEmpty(name) || HasDefinition(name)) { return(false); } _definitions.Add(new VariableDefinition { Name = name, Definition = ValueDefinition.Create(type, null) }); IncrementVersion(); return(true); }
public virtual void GetInputs(IList <VariableDefinition> inputs) { var fields = GetType().GetFields(BindingFlags.Instance | BindingFlags.Public); foreach (var field in fields) { if (field.FieldType == typeof(VariableReference)) { var value = field.GetValue(this) as VariableReference; var constraint = field.GetCustomAttribute <VariableConstraintAttribute>(); var definition = new VariableDefinition { Name = value.RootName, Definition = constraint == null?ValueDefinition.Create(VariableType.Empty) : constraint.Definition }; if (InstructionStore.IsInput(value)) { inputs.Add(definition); } } else if (field.FieldType == typeof(Expression)) { var value = field.GetValue(this) as Expression; value.GetInputs(inputs, InstructionStore.InputStoreName); } else if (field.FieldType == typeof(Message)) { var value = field.GetValue(this) as Message; value.GetInputs(inputs); } else if (typeof(VariableSource).IsAssignableFrom(field.FieldType)) { var value = field.GetValue(this) as VariableSource; var constraint = field.GetCustomAttribute <VariableConstraintAttribute>(); if (constraint != null) { if (value.Type == VariableSourceType.Reference && InstructionStore.IsInput(value.Reference)) { inputs.Add(new VariableDefinition { Name = value.Reference.RootName, Definition = constraint.Definition }); } } else { value.GetInputs(inputs); } } } }
private static VariableValue ResolveValue(ValueDefinition definition, VariableValue value, Object errorContext, string invalidError, string variableName) { if (definition.Type == VariableType.Object && definition.Constraint is ObjectVariableConstraint constraint && value.TryGetObject(out var obj)) { var resolved = ComponentHelper.GetAsObject(constraint.Type, obj); value = VariableValue.Create(resolved); } if (definition.Type != VariableType.Empty && !definition.IsValid(value)) { Debug.LogWarningFormat(invalidError, variableName, errorContext, value); } return(value); }
public VariableDefinition GetOutputDefinition(InstructionOutput output) { if (Instruction) { foreach (var definition in Instruction.Outputs) { if (output.Name == definition.Name) { return(definition); } } } return(new VariableDefinition { Name = output.Name, Definition = ValueDefinition.Create(VariableType.Empty) }); }
public void GetInputs(IList <VariableDefinition> inputs) { #if UNITY_EDITOR // the editor calls this method, and may also edit the text after serialization. The simplest way to make sure it // is correct is to just re Parse. Parse(Text); #endif foreach (var token in _tokens) { if (token.Reference != null && InstructionStore.IsInput(token.Reference)) { inputs.Add(new VariableDefinition { Name = token.Reference.RootName, Definition = ValueDefinition.Create(VariableType.Empty) }); } } }
public override void GetInputs(IList <VariableDefinition> inputs) { Effect.GetInputs(inputs); EffectName.GetInputs(inputs); Position.GetInputs(inputs); Rotation.GetInputs(inputs); if (Positioning == ObjectPositioning.Child && InstructionStore.IsInput(Parent)) { inputs.Add(new VariableDefinition { Name = Parent.RootName, Definition = ValueDefinition.Create <GameObject>() }); } if (Positioning == ObjectPositioning.Relative && InstructionStore.IsInput(Object)) { inputs.Add(new VariableDefinition { Name = Object.RootName, Definition = ValueDefinition.Create <GameObject>() }); } }
public override void GetInputs(IList <VariableDefinition> inputs) { if (Source == InstructionSource.Value) { foreach (var input in Instruction.Inputs) { if (InstructionStore.IsInput(input)) { inputs.Add(Instruction.GetInputDefinition(input)); } } } else if (Source == InstructionSource.Reference) { if (InstructionStore.IsInput(Reference)) { inputs.Add(new VariableDefinition { Name = Reference.RootName, Definition = ValueDefinition.Create <Instruction>() }); } } }
public override void GetInputs(IList <VariableDefinition> inputs) { if (InstructionStore.IsInput(Animator)) { inputs.Add(new VariableDefinition { Name = Animator.RootName, Definition = ValueDefinition.Create <Animator>() }); } Parameter.GetInputs(inputs); switch (Type) { case AnimatorControllerParameterType.Float: FloatValue.GetInputs(inputs); break; case AnimatorControllerParameterType.Int: IntValue.GetInputs(inputs); break; case AnimatorControllerParameterType.Bool: BoolValue.GetInputs(inputs); break; case AnimatorControllerParameterType.Trigger: break; } }
public virtual void GetOutputs(IList <VariableDefinition> outputs) { var fields = GetType().GetFields(BindingFlags.Instance | BindingFlags.Public); foreach (var field in fields) { if (field.FieldType == typeof(VariableReference)) { var value = field.GetValue(this) as VariableReference; if (InstructionStore.IsOutput(value)) { outputs.Add(new VariableDefinition { Name = value.RootName, Definition = ValueDefinition.Create(VariableType.Empty) }); } } else if (field.FieldType == typeof(Expression)) { var value = field.GetValue(this) as Expression; value.GetOutputs(outputs, InstructionStore.OutputStoreName); } } }
public override void GetInputs(IList <VariableDefinition> inputs) { if (InstructionStore.IsInput(Transform)) { inputs.Add(new VariableDefinition { Name = Transform.RootName, Definition = ValueDefinition.Create <Transform>() }); } TargetPosition.GetInputs(inputs); TargetRotation.GetInputs(inputs); TargetScale.GetInputs(inputs); if (AnimationMethod == AnimationType.Duration) { Duration.GetInputs(inputs); } else if (AnimationMethod == AnimationType.Speed) { MoveSpeed.GetInputs(inputs); RotationSpeed.GetInputs(inputs); ScaleSpeed.GetInputs(inputs); } }
public VariableConstraintAttribute(string[] values) { Definition = ValueDefinition.Create(values); }
public VariableConstraintAttribute(Type type) { Definition = ValueDefinition.Create(type); }
public override void AddVariable(string name, VariableValue value) { Definitions.Add(ValueDefinition.Create(value.Type, null, null, null, false, false)); base.AddVariable(name, value); }
public VariableConstraintAttribute(float minimum, float maximum) { Definition = ValueDefinition.Create(minimum, maximum); }