public override void GetInputs(List <VariableDefinition> inputs)
{
if (InstructionStore.IsInput(Parent))
{
inputs.Add(VariableDefinition.Create <GameObject>(Parent.RootName));
}
}
public void GetInputs(List <VariableDefinition> inputs)
{
var start = 0;
while (start < Text.Length)
{
var open = Text.IndexOf('{', start);
var close = Text.IndexOf('}', open + 1);
if (open > start && Text[open - 1] == '\\')
{
start = open + 1;
}
else if (open < 0 || close < 0)
{
break;
}
else
{
var variable = Text.Substring(open + 1, close - open - 1);
_temporaryReference.Update(variable);
if (InstructionStore.IsInput(_temporaryReference))
{
inputs.Add(VariableDefinition.Create(_temporaryReference.RootName, VariableType.String));
}
start = close + 1;
}
}
}
public void GetInputs(List <VariableDefinition> inputs)
{
if (Type == VariableSourceType.Reference && InstructionStore.IsInput(Reference))
{
var type = VariableValue.GetType(typeof(T));
inputs.Add(VariableDefinition.Create(Reference.RootName, type));
}
}
public void GetInputs(IList <VariableDefinition> inputs)
{
if (Type == VariableSourceType.Reference && InstructionStore.IsInput(Reference))
{
var definition = new VariableDefinition {
Name = Reference.RootName, Definition = GetInputDefinition()
};
inputs.Add(definition);
}
}
public override void GetInputs(List <VariableDefinition> inputs)
{
foreach (var input in Instruction.Inputs)
{
if (InstructionStore.IsInput(input))
{
inputs.Add(input.Definition);
}
}
}
public override void GetInputs(List <VariableDefinition> inputs)
{
foreach (var node in Nodes)
{
if (InstructionStore.IsInput(node.This))
{
inputs.Add(VariableDefinition.Create(node.This.RootName, VariableType.Empty));
}
node.GetInputs(inputs);
}
}
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);
}
}
}
}
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 (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 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(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);
}
}
