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()
{
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));
count = ValueOutput(nameof(count), Count);
Requirement(collection, count);
}
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));
lastItem = ValueOutput(nameof(lastItem), First);
Requirement(collection, lastItem);
}
protected override void Definition()
{
base.Definition();
index = ValueOutput <int>(nameof(index));
text = ValueOutput <string>(nameof(text));
}
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 ValueOutput ValueOutput(Type type, string key)
{
EnsureUniqueOutput(key);
var port = new ValueOutput(key, type);
valueOutputs.Add(port);
return(port);
}
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();
other = ValueOutput <GameObject>(nameof(other));
collisionEvents = ValueOutput <List <ParticleCollisionEvent> >(nameof(collisionEvents));
}
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()
{
input = ValueInput <object>(nameof(input)).AllowsNull();
fallback = ValueInput <object>(nameof(fallback));
result = ValueOutput(nameof(result), Coalesce).Predictable();
Requirement(input, result);
Requirement(fallback, result);
}
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()
{
@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));
contains = ValueOutput(nameof(contains), Contains);
Requirement(dictionary, contains);
Requirement(key, contains);
}
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()
{
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()
{
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()
{
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()
{
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()
{
base.Definition();
collider = ValueOutput <Collider>(nameof(collider));
contacts = ValueOutput <ContactPoint[]>(nameof(contacts));
impulse = ValueOutput <Vector3>(nameof(impulse));
relativeVelocity = ValueOutput <Vector3>(nameof(relativeVelocity));
data = ValueOutput <Collision>(nameof(data));
}
protected override void Definition()
{
base.Definition();
name = ValueInput(nameof(name), string.Empty);
floatParameter = ValueOutput <float>(nameof(floatParameter));
intParameter = ValueOutput <int>(nameof(intParameter));
objectReferenceParameter = ValueOutput <GameObject>(nameof(objectReferenceParameter));
}
protected void Connect(ValueOutput source, ValueInput destination)
{
Undo.IncrementCurrentGroup();
LudiqEditorUtility.editedObject.BeginOverride(m_Reference.serializedObject);
var widget = new ValueOutputWidget(m_Canvas, source);
var connectMethodInfo = GetConnectionMethodInfo(widget.GetType());
connectMethodInfo?.Invoke(widget, new object[] { widget.port, destination });
LudiqEditorUtility.editedObject.EndOverride();
}
protected override void Definition()
{
base.Definition();
breakForce = ValueOutput <float>(nameof(breakForce));
breakTorque = ValueOutput <float>(nameof(breakTorque));
connectedBody = ValueOutput <Rigidbody2D>(nameof(connectedBody));
reactionForce = ValueOutput <Vector2>(nameof(reactionForce));
reactionTorque = ValueOutput <float>(nameof(reactionTorque));
joint = ValueOutput <Joint2D>(nameof(joint));
}
protected override void Definition()
{
list = ValueOutput(nameof(list), Merge);
base.Definition();
foreach (var input in multiInputs)
{
Requirement(input, list);
}
}
protected override void Definition()
{
dictionary = ValueOutput(nameof(dictionary), Merge);
base.Definition();
foreach (var input in multiInputs)
{
Requirement(input, dictionary);
}
}
private int Start(Flow flow, out int currentIndex, out int lastIndex, out bool ascending)
{
var firstIndex = flow.GetValue <int>(this.firstIndex);
lastIndex = flow.GetValue <int>(this.lastIndex);
ascending = firstIndex <= lastIndex;
currentIndex = firstIndex;
flow.SetValue(this.currentIndex, currentIndex);
return(flow.EnterLoop());
}
protected override void Definition()
{
base.Definition();
minimum = ValueOutput(nameof(minimum), Operation).Predictable();
foreach (var multiInput in multiInputs)
{
Requirement(multiInput, minimum);
}
}
protected override void Definition()
{
base.Definition();
collider = ValueOutput <Collider>(nameof(collider));
controller = ValueOutput <CharacterController>(nameof(controller));
moveDirection = ValueOutput <Vector3>(nameof(moveDirection));
moveLength = ValueOutput <float>(nameof(moveLength));
normal = ValueOutput <Vector3>(nameof(normal));
point = ValueOutput <Vector3>(nameof(point));
data = ValueOutput <ControllerColliderHit>(nameof(data));
}