protected override void RegisterPorts()
{
if (type == null)
{
type = typeof(System.Enum);
}
var selector = AddValueInput(type.Name, type, "Enum");
if (type != typeof(System.Enum))
{
var enumNames = System.Enum.GetNames(type);
var cases = new FlowOutput[enumNames.Length];
for (var i = 0; i < cases.Length; i++)
{
cases[i] = AddFlowOutput(enumNames[i]);
}
AddFlowInput("In", (f) =>
{
var enumValue = selector.value;
var index = (int)System.Enum.Parse(enumValue.GetType(), enumValue.ToString());
cases[index].Call(f);
});
}
}
protected override void RegisterPorts()
{
onEnable = AddFlowOutput("On Enable");
onDisable = AddFlowOutput("On Disable");
onDestroy = AddFlowOutput("On Destroy");
AddValueOutput <GameObject>("Receiver", () => { return(receiver); });
}
protected override void RegisterPorts()
{
//base.RegisterPorts();
AddFlowInput("Cast", (f) =>
{
try
{
if (typeof(T).IsPrimitive)
{
result = (T)Convert.ChangeType(castSource.value, typeof(T));
}
else
{
result = (T)(castSource.value);
}
castSuccessFlow.Call(f);
}
catch
{
result = default(T);
castFailureFlow.Call(f);
}
});
castSource = AddValueInput <object>("source");
castSuccessFlow = AddFlowOutput("Success");
castFailureFlow = AddFlowOutput("Failure");
AddValueOutput("target", () => result);
}
protected override void RegisterPorts()
{
onAnimatorMove = AddFlowOutput("On Animator Move");
onAnimatorIK = AddFlowOutput("On Animator IK");
AddValueOutput <Animator>("Receiver", () => { return(this.receiver); });
AddValueOutput <int>("Layer Index", () => { return(layerIndex); });
}
protected override void RegisterPorts()
{
var selector = AddValueInput <int>("Value", "Index");
var cases = new FlowOutput[intCases.Count];
for (var i = 0; i < cases.Length; i++)
{
cases[i] = AddFlowOutput(intCases[i].ToString(), i.ToString());
}
var defaultCase = AddFlowOutput("Default");
AddFlowInput("In", (f) =>
{
var selectorValue = selector.value;
var caseCalled = false;
for (var i = 0; i < intCases.Count; i++)
{
if (selectorValue == intCases[i])
{
caseCalled = true;
cases[i].Call(f);
}
}
if (!caseCalled)
{
defaultCase.Call(f);
}
});
}
protected override void RegisterPorts()
{
if (eventInfo == null)
{
return;
}
var delegateType = eventInfo.EventHandlerType;
if (reflectedEvent == null)
{
reflectedEvent = new ReflectedDelegateEvent(delegateType);
}
if (!isStaticEvent)
{
instancePort = AddValueInput(eventInfo.RTReflectedOrDeclaredType().FriendlyName(), eventInfo.RTReflectedOrDeclaredType(), "Instance");
}
var parameters = delegateType.RTGetDelegateTypeParameters();
args = new object[parameters.Length];
for (var _i = 0; _i < parameters.Length; _i++)
{
var i = _i;
var parameter = parameters[i];
AddValueOutput(parameter.Name, "arg" + i, parameter.ParameterType, () => { return(args[i]); });
}
callback = AddFlowOutput(eventInfo.Name, "Event");
}
protected override void RegisterPorts()
{
original = AddValueInput <GameObject>("original");
pos = AddValueInput <Vector3>("position");
eulerAngles = AddValueInput <Vector3>("eulerAngles");
parent = AddValueInput <Transform>("parent");
AddValueOutput <GameObject>("original", () => result);
if (callable)
{
Output = AddFlowOutput("Out");
AddFlowInput("In", (f) => Output.Call(f));
if (parent == null)
{
result = Object.Instantiate(original.value, pos.value, Quaternion.Euler(eulerAngles.value.x, eulerAngles.value.y, eulerAngles.value.z));
}
if (parent != null)
{
result = Object.Instantiate(original.value, pos.value, Quaternion.Euler(eulerAngles.value.x, eulerAngles.value.y, eulerAngles.value.z),
parent.value);
}
}
else
{
if (parent == null)
{
result = Object.Instantiate(original.value, pos.value, Quaternion.Euler(eulerAngles.value.x, eulerAngles.value.y, eulerAngles.value.z));
}
if (parent != null)
{
result = Object.Instantiate(original.value, pos.value, Quaternion.Euler(eulerAngles.value.x, eulerAngles.value.y, eulerAngles.value.z),
parent.value);
}
}
}
protected override void RegisterPorts()
{
#if UNITY_EDITOR
if (!ParadoxNotion.Services.Threader.applicationIsPlaying)
{
_tagNames = UnityEditorInternal.InternalEditorUtility.tags;
}
#endif
if (_tagNames == null)
{
return;
}
var selector = AddValueInput <GameObject>("Value");
var cases = new FlowOutput[_tagNames.Length];
for (var i = 0; i < cases.Length; i++)
{
cases[i] = AddFlowOutput(_tagNames[i], i.ToString());
}
AddFlowInput("In", (f) =>
{
for (var i = 0; i < _tagNames.Length; i++)
{
if (_tagNames[i] == selector.value.tag)
{
cases[i].Call(f);
}
}
});
}
protected override void RegisterPorts() {
onEnter = AddFlowOutput("Enter");
onStay = AddFlowOutput("Stay");
onExit = AddFlowOutput("Exit");
AddValueOutput<Collider>("Receiver", () => { return receiver; });
AddValueOutput<GameObject>("Other", () => { return other; });
}
protected override void RegisterPorts()
{
delegateType = delegateType != null ? delegateType : typeof(Delegate);
delegatePort = AddValueOutput(delegateType.FriendlyName(), "Delegate", delegateType, () => { return(reflectedEvent.AsDelegate()); });
callbackPort = AddFlowOutput("Callback");
if (delegateType == typeof(Delegate))
{
return;
}
if (reflectedEvent == null)
{
reflectedEvent = new ReflectedDelegateEvent(delegateType);
reflectedEvent.Add(Callback);
}
var parameters = delegateType.RTGetDelegateTypeParameters();
for (var _i = 0; _i < parameters.Length; _i++)
{
var i = _i;
var parameter = parameters[i];
AddValueOutput(parameter.Name, "arg" + i, parameter.ParameterType, () => { return(args[i]); });
}
}
protected override void RegisterPorts()
{
onValueChanged = AddFlowOutput("Value Changed");
onEndEdit = AddFlowOutput("End Edit");
AddValueOutput <UnityEngine.UI.InputField>("This", () => { return(base.target.value); });
AddValueOutput <string>("Value", () => { return(value); });
}
protected override void OnRegisterPorts(FlowNode node)
{
//to make update safe from previous version, the ID (2nd string), is same as the old version. The first string, is the actual name.
outFlow = node.AddFlowOutput("Start", "Out");
doing = node.AddFlowOutput("Update", "Doing");
done = node.AddFlowOutput("Finish", "Done");
}
protected override void RegisterPorts()
{
type = type != null? type : typeof(SharpEvent);
eventInput = AddValueInput("Event", type);
if (type == typeof(SharpEvent))
{
return;
}
var delegateType = type.RTGetGenericArguments()[0];
if (reflectedEvent == null)
{
reflectedEvent = new ReflectedDelegateEvent(delegateType);
}
var parameters = delegateType.RTGetDelegateTypeParameters();
for (var _i = 0; _i < parameters.Length; _i++)
{
var i = _i;
var parameter = parameters[i];
AddValueOutput(parameter.Name, "arg" + i, parameter.ParameterType, () => { return(argValues[i]); });
}
flowCallback = AddFlowOutput("Callback");
if (!autoHandleRegistration)
{
AddFlowInput("Register", Register, "Add");
AddFlowInput("Unregister", Unregister, "Remove");
}
}
protected override void RegisterPorts()
{
eventType = eventType != null? eventType : typeof(UnityEventBase);
eventInput = AddValueInput("Event", eventType);
if (eventType == typeof(UnityEventBase))
{
return;
}
if (reflectedEvent == null)
{
reflectedEvent = new ReflectedUnityEvent(eventType);
}
if (reflectedEvent.eventType != eventType)
{
reflectedEvent.InitForEventType(eventType);
}
argValues = new object[reflectedEvent.parameters.Length];
for (var _i = 0; _i < reflectedEvent.parameters.Length; _i++)
{
var i = _i;
var parameter = reflectedEvent.parameters[i];
AddValueOutput(parameter.Name, "arg" + i, parameter.ParameterType, () => { return(argValues[i]); });
}
callback = AddFlowOutput("Callback");
if (!autoHandleRegistration)
{
AddFlowInput("Register", Register, "Add");
AddFlowInput("Unregister", Unregister, "Remove");
}
}
protected override void RegisterPorts()
{
if (field == null)
{
return;
}
if (reflectedEvent == null)
{
reflectedEvent = new ReflectedUnityEvent(field.FieldType);
}
if (!field.IsStatic)
{
instancePort = AddValueInput(field.RTReflectedType().FriendlyName(), field.RTReflectedType(), "Instance");
}
args = new object[reflectedEvent.parameters.Length];
for (var _i = 0; _i < reflectedEvent.parameters.Length; _i++)
{
var i = _i;
var parameter = reflectedEvent.parameters[i];
AddValueOutput(parameter.Name, "arg" + i, parameter.ParameterType, () => { return(args[i]); });
}
callback = AddFlowOutput(field.Name, "Event");
}
protected override void RegisterPorts()
{
var selector = AddValueInput <string>("Value");
var cases = new FlowOutput[comparisonOutputs.Count];
for (var i = 0; i < cases.Length; i++)
{
cases[i] = AddFlowOutput(string.Format("\"{0}\"", comparisonOutputs[i]), i.ToString());
}
var defaultCase = AddFlowOutput("Default");
AddFlowInput("In", (f) =>
{
var selectorValue = selector.value;
var caseCalled = false;
if (selectorValue != null)
{
for (var i = 0; i < comparisonOutputs.Count; i++)
{
if (selectorValue.Equals(comparisonOutputs[i], System.StringComparison.OrdinalIgnoreCase))
{
caseCalled = true;
cases[i].Call(f);
}
}
}
if (!caseCalled)
{
defaultCase.Call(f);
}
});
}
protected override void RegisterPorts()
{
if (!string.IsNullOrEmpty(eventName))
{
o = AddFlowOutput(eventName);
}
}
protected override void RegisterPorts()
{
AddValueOutput <CustomEventListener>("Event", () => this);
onReceived = AddFlowOutput("Dispatched");
AddValueOutput <GraphOwner>("Receiver", () => { return(receiver); });
AddValueOutput <GraphOwner>("Sender", () => { return(sender); });
}
protected override void RegisterPorts()
{
hit = AddFlowOutput("Collider Hit");
AddValueOutput <GameObject>("Other", () => { return(hitInfo.gameObject); });
AddValueOutput <Vector3>("Collision Point", () => { return(hitInfo.point); });
AddValueOutput <ControllerColliderHit>("Collision Info", () => { return(hitInfo); });
}
protected override void RegisterPorts()
{
enter = AddFlowOutput("Enter");
stay = AddFlowOutput("Stay");
exit = AddFlowOutput("Exit");
AddValueOutput <GameObject>("Other", () => { return(other); });
}
protected override void RegisterPorts()
{
eventListener = AddValueInput <CustomEventListener>("EventListener", "");
if (targetMode == 0)
{
target = AddValueInput <GraphOwner>("AttachGraphOwner");
}
else
{
targetList = AddValueInput <List <GraphOwner> >("AttachGraphOwners");
}
outPutFlow = AddFlowOutput("Out", "");
AddFlowInput("In", (f) => {
eventListener.value.targetMode = targetMode;
if (targetMode == 0)
{
if (eventListener.value.targets != null && eventListener.value.targets.value != null && eventListener.value.targets.value.Count > 1)
{
eventListener.value.targetMode = TargetMode.MultipleTargets;
}
if (target.value == null || target.value == eventListener.value.target.value)
{
}
else
{
if (eventListener.value.target.value == null)
{
eventListener.value.target.value = target.value;
}
else
{
eventListener.value.targetMode = TargetMode.MultipleTargets;
if (eventListener.value.targets.value == null)
{
eventListener.value.targets.value = new List <GraphOwner>();
}
if (!eventListener.value.targets.value.Contains(target.value))
{
eventListener.value.targets.value.Add(target.value);
}
if (eventListener.value.target.value != null && !eventListener.value.targets.value.Contains(eventListener.value.target.value))
{
eventListener.value.targets.value.Add(eventListener.value.target.value);
}
}
}
}
else
{
eventListener.value.targets.value = targetList.value;
}
eventListener.value.Register();
outPutFlow.Call(f);
});
}
protected override void RegisterPorts()
{
//base.RegisterPorts();
levelLoaded = AddFlowOutput("LevelLoaded");
AddValueOutput("loadedScene", () => { return(loadedScene); });
AddValueOutput("loadedSceneIndex", () => { return(loadedScene.buildIndex); });
AddValueOutput("loadedSceneName", () => { return(loadedScene.name); });
}
protected override void RegisterPorts()
{
#if UNITY_EDITOR
o = AddFlowOutput("Out");
#else
AddFlowOutput("Out"); //a stub
#endif
}
protected override void RegisterPorts()
{
onParentChanged = AddFlowOutput("On Transform Parent Changed");
onChildrenChanged = AddFlowOutput("On Transform Children Changed");
AddValueOutput <Transform>("Receiver", () => { return(receiver); });
AddValueOutput <Transform>("Parent", () => { return(parent); });
AddValueOutput <IEnumerable <Transform> >("Children", () => { return(children); });
}
protected override void RegisterPorts(){
onCollision = AddFlowOutput("On Particle Collision");
AddValueOutput<Collider>("Receiver", ()=> {return receiver; });
AddValueOutput<ParticleSystem>("Particle System", ()=> { return particle; });
AddValueOutput<Vector3>("Collision Point", ()=> { return collisionEvents[0].intersection; });
AddValueOutput<Vector3>("Collision Normal", ()=> { return collisionEvents[0].normal; });
AddValueOutput<Vector3>("Collision Velocity", ()=> { return collisionEvents[0].velocity; });
}
protected override void RegisterPorts()
{
becameTrue = AddFlowOutput("Became True");
becameFalse = AddFlowOutput("Became False");
//isTrue = AddFlowOutput("Is True");
//isFalse = AddFlowOutput("Is False");
condition = AddValueInput <bool>("Condition");
}
protected override void RegisterPorts()
{
fOut = AddFlowOutput("Out");
for (var _i = 0; _i < portCount; _i++)
{
var i = _i;
AddFlowInput(i.ToString(), (f) => { fOut.Call(f); });
}
}
protected override void RegisterPorts()
{
enter = AddFlowOutput("Enter");
stay = AddFlowOutput("Stay");
exit = AddFlowOutput("Exit");
AddValueOutput <GameObject>("Other", () => { return(collision.gameObject); });
AddValueOutput <ContactPoint>("Contact Point", () => { return(collision.contacts[0]); });
AddValueOutput <Collision>("Collision Info", () => { return(collision); });
}
protected override void RegisterPorts()
{
onInvoke = AddFlowOutput(" ");
for (var _i = 0; _i < parameters.Count; _i++)
{
var i = _i;
var parameter = parameters[i];
AddValueOutput(parameter.name, parameter.ID, parameter.type, () => { return(args[i]); });
}
}
protected override void RegisterPorts()
{
calls = new int[_portCount];
fOut = AddFlowOutput("Out");
for (var _i = 0; _i < _portCount; _i++)
{
var i = _i;
AddFlowInput(i.ToString(), (f) => { Check(i, f); });
}
}
