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);
}
