Nodes and Bindings

Nodes

Nodes are the fundamental elements from which a Ventuz Scene is constructed. Each node is either a Layer, Content or Hierarchy Node and thus belongs either in the Layer Editor, Content Editor or Hierarchy Editor.

This is visualized by the orientation of the brackets around the node icon.

A hierarchy node has vertical brackets, a content node horizontal brackets and a layer node corners around the node icon.

All nodes can be browsed via one of the Toolboxes. These can be accessed either through the toolbox window (accessible via View/Toolbox in the menu bar) or by clicking into the Layer Editor, Hierarchy Editor or Content Editor and then pressing the Space key to open the Fast Toolbox.

Layer Nodes

Layer Nodes are somewhat special in that they represent a 2D Compositing Layer - everything inside a Layer will be rendered onto a dedicated texture and then composited together with all other Layers using the Layer Effects and the Layer Blending and Masking.

Hierarchy Nodes

A hierarchy node is like an instruction to the Ventuz Rendering Engine, for example to activate a certain material or texture, to render a mesh and so forth.

Content Nodes

A content node describes an asset (i.e. a texture, an XML file, ...), a numeric constant, an event or any other item that does not directly influence the rendering process.

Primary Nodes

Primary Nodes are Hierarchy and Layer Nodes, except the following ones:

• Hierarchy Container
• Container Output
• Switch and Yes/No Switch
• Layer Switch
• Axis
• Set World
• Get World
• Billboard
• Shear
• Group
• Layer Group
• ZSort

In terms of the limitation of the Community Edition Primary Nodes are counted through the whole currently active Scene Tree. Especially when working in the Ventuz Designer you need to keep in mind that not only the Nodes in the current Scene are counted. The node count of the currently open scene can be found in the scene tab, the node count of the whole scene tree is found in the System Information of the Performance Statistics.

Example

Below you can find a very common scene tree setup. One main scene loads and displays several sub-scenes. The limit exceedance depends on how many nodes each scene has. For the examples we assume a limit of 500 nodes:

• Case 1 - The_Office and all seven sub-scenes each have 50 nodes: The limit is not exceeded as in sum they have 400 nodes.
• Case 2 - The_Office and all seven sub-scenes each have 100 nodes: The limit is exceeded as in sum the scenes have 800 nodes, although each scene alone has less than the given limit.

Properties and Bindings

Each node has a number of Input Properties that are parameters which affect the nodes behavior (i.e. the size of a Rectangle or the speed a video is played). A node can also have a number of Output Properties that can be used to feed the input properties of other nodes. This is done via Bindings.

As long as an Input property is bound, it will update its value whenever the Output property of the bound node changes. For example, the X-Rotation property of a Axis node can be bound to a Mover node to continuously have objects under the Axis rotate around the X-axis. Binding of node properties is at the heart of Ventuz and allows the creation of very complex logic without having to program a single line of code.

Bindings are visualized as arrows which connect nodes in the Content Editor. To create a binding, select a node, go to the Properties Editor and drag the input property onto another node. When released, Ventuz will open up a list of compatible output properties of that second node. Upon choosing one of the properties, a connection is created and visualized by an arrow going from the output node to the input node. For more information, see Property Editor. When a node is selected its bindings will be highlighted as shown in the picture above.

A binding can be removed by clicking on the arrow that represents the binding. A list of all bindings will appear and by clicking any of the crosses, the respective binding will be removed.

Layer to Layer Bindings

It is possible to have bindings across Layers. Before you can use a property and bind it from one to another layer, or bind the property to the Layer Level content nodes you have to expose the values up to the Layer Level. The following screenshots show a Touch Button which has the TouchPressed exposed from the 3d Layer (User interface) and is bound to the 2D Movie Clip Layer to control the Play.

Inside the Layer3D - exposed the SingleTap
Layer Level - The exposed SingleTap is visible and can be bound
The Play event from the 2D Movie Clip Layer is bound to the SingleTap

Validation and Rendering

What makes Ventuz unique is that a scene is not a static or linearly animated collection of assets but a flexible construct. As input changes, geometries are moved or scaled, materials changed, animations played or stopped, certain areas become responsive to touch and others ignore it. To handle all of this in realtime, the amount of processing has to be reduced to the absolute required minimum.

Ventuz uses a two-step approach, first validating each node to ensure that its values have been updated and only once all nodes are valid, rendering is performed in a second step. During validation, a node uses the values of its input properties to drive the internal functional implementation, thus updating the values of its output properties and/or data used during rendering. For example, a Rectangle Node might recreate its mesh as the tessellation level changes or an Expression Node might calculate its new output value based on a changed input.

To do all of this in an efficient manner, each node stores its validation state. If the output property of a node changes its value, all nodes bound to that output get invalidated. If none of the bound outputs changes and neither does the user change an input property by hand, there is no reason to re-validate the node.

In most cases however, the user luckily does not have to worry about any part of this. Ventuz will utilize all means available to it in order to update the scene as fast as possible, making it ready to render the next frame.