protected override void Definition()
{
base.Definition();
index = ValueOutput <int>(nameof(index));
text = ValueOutput <string>(nameof(text));
}
protected override void Definition()
{
input = ValueInput(nameof(input), default(T));
output = ValueOutput(nameof(output), Operation);
Requirement(input, output);
}
protected override void Definition()
{
selection = ValueOutput(nameof(selection), Result).Predictable();
selector = ValueInput <T>(nameof(selector));
Requirement(selector, selection);
branches = new List <KeyValuePair <T, ValueInput> >();
foreach (var option in options)
{
var key = "%" + option;
if (!valueInputs.Contains(key))
{
var branch = ValueInput <object>(key).AllowsNull();
branches.Add(new KeyValuePair <T, ValueInput>(option, branch));
Requirement(branch, selection);
}
}
@default = ValueInput <object>(nameof(@default));
Requirement(@default, selection);
}
protected override void Definition()
{
collection = ValueInput <IEnumerable>(nameof(collection));
firstItem = ValueOutput(nameof(firstItem), First);
Requirement(collection, firstItem);
}
protected override void Definition()
{
input = ValueInput <T>(nameof(input));
output = ValueOutput(nameof(output), Operation).Predictable();
Requirement(input, output);
}
protected override void Definition()
{
enter = ControlInput(nameof(enter), Enter);
reset = ControlInput(nameof(reset), Reset);
duration = ValueInput(nameof(duration), 1f);
unscaledTime = ValueInput(nameof(unscaledTime), false);
exitReady = ControlOutput(nameof(exitReady));
exitNotReady = ControlOutput(nameof(exitNotReady));
tick = ControlOutput(nameof(tick));
becameReady = ControlOutput(nameof(becameReady));
remainingSeconds = ValueOutput <float>(nameof(remainingSeconds));
remainingRatio = ValueOutput <float>(nameof(remainingRatio));
Requirement(duration, enter);
Requirement(unscaledTime, enter);
Succession(enter, exitReady);
Succession(enter, exitNotReady);
Succession(enter, tick);
Succession(enter, becameReady);
Assignment(enter, remainingSeconds);
Assignment(enter, remainingRatio);
}
protected override void Definition()
{
collection = ValueInput <IEnumerable>(nameof(collection));
count = ValueOutput(nameof(count), Count);
Requirement(collection, count);
}
protected override void Definition()
{
if (this is IDefaultValue <T> defaultValueUnit)
{
var mi = new List <ValueInput>();
multiInputs = mi.AsReadOnly();
for (var i = 0; i < inputCount; i++)
{
if (i == 0)
{
mi.Add(ValueInput <T>(i.ToString()));
continue;
}
mi.Add(ValueInput(i.ToString(), defaultValueUnit.defaultValue));
}
}
else
{
base.Definition();
}
sum = ValueOutput(nameof(sum), Operation).Predictable();
foreach (var multiInput in multiInputs)
{
Requirement(multiInput, sum);
}
}
protected override void Definition()
{
a = ValueInput <float>(nameof(a));
b = ValueInput <float>(nameof(b), 0);
aLessThanB = ValueOutput(nameof(aLessThanB), Less).Predictable();
aLessThanOrEqualToB = ValueOutput(nameof(aLessThanOrEqualToB), LessOrEqual).Predictable();
aEqualToB = ValueOutput(nameof(aEqualToB), Equal).Predictable();
aGreaterThanOrEqualToB = ValueOutput(nameof(aGreaterThanOrEqualToB), GreaterOrEqual).Predictable();
aGreatherThanB = ValueOutput(nameof(aGreatherThanB), Greater).Predictable();
Requirement(a, aLessThanB);
Requirement(b, aLessThanB);
Requirement(a, aLessThanOrEqualToB);
Requirement(b, aLessThanOrEqualToB);
Requirement(a, aEqualToB);
Requirement(b, aEqualToB);
Requirement(a, aGreaterThanOrEqualToB);
Requirement(b, aGreaterThanOrEqualToB);
Requirement(a, aGreatherThanB);
Requirement(b, aGreatherThanB);
}
protected override void Definition()
{
enter = ControlInput(nameof(enter), Enter);
exit = ControlOutput(nameof(exit));
output = ValueOutput(type, nameof(output), Create);
Succession(enter, exit);
}
protected override void Definition()
{
base.Definition();
isDefined = ValueOutput(nameof(isDefined), IsDefined);
Requirement(name, isDefined);
}
protected override void Definition()
{
base.Definition();
other = ValueOutput <GameObject>(nameof(other));
collisionEvents = ValueOutput <List <ParticleCollisionEvent> >(nameof(collisionEvents));
}
protected ValueOutput ValueOutput(Type type, string key, Func <Flow, object> getValue)
{
EnsureUniqueOutput(key);
var port = new ValueOutput(key, type, getValue);
valueOutputs.Add(port);
return(port);
}
protected override void Definition()
{
base.Definition();
value = ValueOutput(nameof(value), Get).PredictableIf(IsDefined);
Requirement(name, value);
}
protected ValueOutput ValueOutput(Type type, string key)
{
EnsureUniqueOutput(key);
var port = new ValueOutput(key, type);
valueOutputs.Add(port);
return(port);
}
protected override void Definition()
{
list = ValueInput <IList>(nameof(list));
index = ValueInput(nameof(index), 0);
item = ValueOutput(nameof(item), Get);
Requirement(list, item);
Requirement(index, item);
}
protected override void Definition()
{
base.Definition();
stringParameter = ValueOutput <string>(nameof(stringParameter));
floatParameter = ValueOutput <float>(nameof(floatParameter));
intParameter = ValueOutput <int>(nameof(intParameter));
objectReferenceParameter = ValueOutput <UnityObject>(nameof(objectReferenceParameter));
}
protected override void Definition()
{
a = ValueInput <bool>(nameof(a));
b = ValueInput <bool>(nameof(b));
result = ValueOutput(nameof(result), Operation).Predictable();
Requirement(a, result);
Requirement(b, result);
}
protected override void Definition()
{
a = ValueInput <T>(nameof(a));
b = ValueInput(nameof(b), defaultB);
product = ValueOutput(nameof(product), Operation).Predictable();
Requirement(a, product);
Requirement(b, product);
}
protected override void Definition()
{
dividend = ValueInput(nameof(dividend), defaultDividend);
divisor = ValueInput(nameof(divisor), defaultDivisor);
quotient = ValueOutput(nameof(quotient), Operation).Predictable();
Requirement(dividend, quotient);
Requirement(divisor, quotient);
}
protected override void Definition()
{
minuend = ValueInput(nameof(minuend), defaultMinuend);
subtrahend = ValueInput(nameof(subtrahend), defaultSubtrahend);
difference = ValueOutput(nameof(difference), Operation).Predictable();
Requirement(minuend, difference);
Requirement(subtrahend, difference);
}
protected override void Definition()
{
radicand = ValueInput <float>(nameof(radicand), 1);
degree = ValueInput <float>(nameof(degree), 2);
root = ValueOutput(nameof(root), Root);
Requirement(radicand, root);
Requirement(degree, root);
}
protected override void Definition()
{
a = ValueInput <float>(nameof(a));
b = ValueInput <float>(nameof(b), 0);
notEqual = ValueOutput(nameof(notEqual), Comparison).Predictable();
Requirement(a, notEqual);
Requirement(b, notEqual);
}
protected override void Definition()
{
dictionary = ValueInput <IDictionary>(nameof(dictionary));
key = ValueInput <object>(nameof(key));
contains = ValueOutput(nameof(contains), Contains);
Requirement(dictionary, contains);
Requirement(key, contains);
}
protected override void Definition()
{
list = ValueInput <IList>(nameof(list));
item = ValueInput <object>(nameof(item));
contains = ValueOutput(nameof(contains), Contains);
Requirement(list, contains);
Requirement(item, contains);
}
protected override void Definition()
{
a = ValueInput <T>(nameof(a));
b = ValueInput <T>(nameof(b));
distance = ValueOutput(nameof(distance), Operation).Predictable();
Requirement(a, distance);
Requirement(b, distance);
}
protected override void Definition()
{
base.Definition();
collider = ValueOutput <Collider2D>(nameof(collider));
contacts = ValueOutput <ContactPoint2D[]>(nameof(contacts));
relativeVelocity = ValueOutput <Vector2>(nameof(relativeVelocity));
enabled = ValueOutput <bool>(nameof(enabled));
data = ValueOutput <Collision2D>(nameof(data));
}
protected override void Definition()
{
@base = ValueInput <float>(nameof(@base), 1);
exponent = ValueInput <float>(nameof(exponent), 2);
power = ValueOutput(nameof(power), Exponentiate);
Requirement(@base, power);
Requirement(exponent, power);
}
protected override void Definition()
{
dictionary = ValueInput <IDictionary>(nameof(dictionary));
key = ValueInput <object>(nameof(key));
value = ValueOutput(nameof(value), Get);
Requirement(dictionary, value);
Requirement(key, value);
}
protected override void Definition()
{
dividend = ValueInput(nameof(dividend), defaultDividend);
divisor = ValueInput(nameof(divisor), defaultDivisor);
remainder = ValueOutput(nameof(remainder), Operation).Predictable();
Requirement(dividend, remainder);
Requirement(divisor, remainder);
}
