Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
This collection of OverNodes represents all the nodes that interact with the physics Unity Collision system.
The main element of this collection consists of a Collision Node, that fires its execution on detecting a specific Collision event.
Each Collision Node must refer to a specific Target GameObject, accordingly equipped with a Unity Collider Component. Once a collision is detected, the following nodes will be executed.
A Mode parameter can be selected in order to further customize the execution of the node, specifically:
| Name | Description |
|---|---|
The Node also exposes some parameters, also describing the Collision itself:
| Name | Type | Description |
|---|---|---|
In order for the Node system to communicate with the Unity Runtime environment, a OverCollisionListener component must be associated with the Target GameObject.
Its main function is to provide a bridge between the node system and the UnityEngine event system, which handles collision events automatically.
This node is used to expose certain parameters and attributes of a given input Unity Collider Component, which are:
| Name | Type | Description |
|---|---|---|
Ref
A reference of the input Unity Collider Component
Object
GameObject associated to the collider
Enter
Sets the node to be executed when a physical object enters the Target Collider space
Stay
Sets the node to be executed when a physical object stays inside the Target Collider space
Exit
Sets the node to be executed when a physical object exits the Target Collider space
Other
A reference of the input Unity Collider Component of the object colliding with the Target
Contacts
ContactPoint [ ]
List of contact points where the collision occurs
Impulse
Vector3
The total impulse applied to this contact pair to resolve the collision
Relative Velocity
Vector3
The relative linear velocity of the two colliding objects (Read Only)
This collection of OverNode represents all the nodes that interact with the physics Unity Trigger system.
GameObjects involved in the collision must contain a Collider component. One must have Collider.isTrigger enabled, and contain a Rigidbody. If both GameObjects have Collider.isTrigger enabled, no collision happens. The same applies when both GameObjects do not have a Rigidbody component.
The main element of this system consists of a Trigger Node, that fires its execution on detecting a specific Trigger event.
Each Trigger Node must refer to a specific Target GameObject, accordingly equipped with a Unity3D Collider Component.
A Mode parameter can be selected in order to further customize the execution of the node, specifically:
| Name | Description |
|---|---|
The Node also exposes some parameters:
| Name | Type | Description |
|---|---|---|
For the Node system to communicate to the Unity3D Runtime environment, an OverTriggerListener component must be associated with the Target GameObject.
Its main function is to provide a bridge between the node system and the UnityEngine event system, which handles trigger events automatically.
The "Trigger Lazy Load" node is designed to register a trigger event on a GameObject. When the GameObject's collider interacts with another collider in a specified mode (Enter, Exit, Stay), the node triggers an event.
| Property | Type | Description |
|---|---|---|
Target
GameObject
The input slot for the GameObject which is monitored for trigger events.
Other
Collider
The output slot that will output the Collider that interacted with the target GameObject's Collider.
Mode
Enum (Dropdown)
A dropdown menu that allows selection of the trigger interaction mode: Enter, Exit, or Stay.
Enter
Sets the node to be executed when a physical object enters the Target Collider space
Stay
Sets the node to be executed when a physical object stays inside the Target Collider space
Exit
Sets the node to be executed when a physical object exits the Target Collider space
Other
A reference of the input Unity3D Collider Component of the object colliding with the Target
This OverNode allows for the implementation of Button-click based events inside the Graph.
A GameObject containing a UI Button must be provided in order to register the onCLick event. Once the button is clicked, the nodes following will be executed.
OVER SDK Visual Scripting also provides the User a tool to define and use Custom events.
These events need to be defined inside a Graph and are only usable inside such.
Each Custom Event Node must be defined by a (unique) Name. In order to fire this event use a Custom Event Trigger
In order to fire a defined Custom Event, a Custom Event Trigger needs to be inserted in another execution flow of the Graph.
By editing its Name parameter, it is possible to fire the execution of the Custom Event Node with the corresponding name.
This collection of OverNodes is used to describe the main flow of the OverGraph. The following nodes are directly connected to the Unity3D Monobehaviour of the OverScript, to which the Graph refers.
Awake is called once when the script instance is being loaded – exactly once in the lifetime of the script.
It is commonly used to describe the logic that should be executed before the first frame is played, acting as a general initialization stage of the script.
Start is called once on the frame when a script is enabled just before any of the Update methods are called the first time.
However, Awake is called when the script object is initialized, regardless of whether or not the script is enabled.
It is commonly used to describe the logic that should be executed on the first frame, acting as a general initialization stage of the script.
This function is called when the object becomes enabled and active.
This function is called when the object becomes disabled.
This is also called when the object is destroyed and can be used for any cleanup code. When scripts are reloaded after compilation has finished, OnDisable will be called, followed by an OnEnable after the script has been loaded.
This function is called when the object is destroyed.
This also occurs when a Scene or game ends. Called always after OnDisable.
If the script is active and enabled, Update is called every frame, once per frame.
It is the most commonly used function to implement any kind of game script, allowing the implementation of logic to be executed at runtime.
Like Update, also LateUpdate is executed once per frame, but after all the nodes in Update have finished executing.
This is useful to give the execution flow and order. It is commonly used to handle animations and camera movements, because it tracks objects that might have moved inside Update.
Similar to Update, FixedUpdate is a frame-rate independent node, called repeatedly based on a fixed frequency, given by the Unity3D Physics system.
This is crucial to handle calculations featuring Rigidbodies and Collisions.
This collection of OverNodes represents all the nodes that interact with common interactions in Mobile devices, such as finger pressing.
The main element of this system consists of a Touch Node, responsible to fire its execution on detecting a specific Touch event.
Each Touch Node must refer to a specific Target GameObject, accordingly equipped with a Unity Collider Component. Once a touch is detected and the Target is hit by the touch, the following nodes will be executed.
A Touch Mode parameter can be selected in order to further customize the execution of the node, specifically:
| Name | Description |
|---|---|
The Node also exposes some parameters:
| Name | Type | Description |
|---|---|---|
In order for the Node system to communicate to the Unity Runtime environment, a OverTouchListener component must be associated to the Target GameObject.
Its main function is to provide a bridge between the node system and the UnityEngine event system, which handles touch events in automatic.
This node is used within a visual scripting framework to register an event that is triggered by an animation. The event is specified by a name, and when that particular animation event is fired, it triggers the node, executing the attached nodes.
Because is used internally, in the Unity Animation Event properties make sure not to use the 'String' parameter (it will get overridden from the visual scripting).
To use this node create a in an animation clip inside the animator and name it. To retrieve it, add the same event name to the node.
| Property | Type | Description |
|---|
Target | Animator | The input slot for the Animator component that will be listened to for animation events. |
Event Name | String | The input slot for the name of the specific animation event to listen for. |
Click
Sets the node to be executed when a click is detected.
Press
Sets the node to be executed when a finger press is detected.
Long Press
Sets the node to be executed when a finger pressing for more than 0.5s is detected.
Other
A reference of the input Unity Collider Component of the object touched
This OverNode allows a sub-set of connected Nodes to be grouped up.
This is a Flow Node, in which the flow is divided into two branches, represented by two output flow ports.
The Body branch represents the entry point of the scope of the Group Node itself, allowing the execution of the following grouped nodes. Once the flow inside the Group is executed, the main branch (represented by the upper right corner port) is resumed.
To better describe the Group Node inside the Graph and its purpose, a Name parameter could be edited.
This allows the implementation of while-loops.
This is a Flow Node, in which the flow is divided into two branches, represented by two output flow ports.
The Condition parameter describes the validity of the condition necessary for the loop to function. While this condition is True, Body will be executed. Inside the body resides all the logic of the loop, described as a collection of joined Nodes.
Once the condition is False, the main branch (upper right port) is resumed, and the loop finishes its computation.
The "List Iterate" node provides a loop mechanism to iterate over each element within a list. It receives a list as input and sequentially outputs each element and its corresponding index. The node is essential for workflows that require processing or examining each item in a collection. It automatically triggers the execution of connected nodes for each item in the list and then proceeds to the next operation once the entire list has been processed.
| Name | Type | Description |
|---|
List | IList | An input slot for the list to be iterated over. |
Body | OverExecutionFlowData | An execution output that triggers the connected nodes for each iteration over the list. |
Current Index | int | An output slot that provides the index of the current element being processed in the list. |
Current Element | object | An output slot that provides the current element from the list being processed. |
This allows the implementation of for-loops.
This is a Flow Node, in which the flow is divided into two branches, represented by two output flow ports.
The Count parameter is used to define how many iterations this Node should execute its Body. Inside the body resides all the logic of the loop, described as a collection of joined Nodes.
In order to keep track of the progression of the loop, Current Step keeps track of the current step of the loop.
Once the loop has finished its computation, the main branch (upper right port) is resumed.
