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