Event Handling Callbacks

Triggers are used to detect changes in nodes position or state. Unigine offers three types of built-in triggers:

NodeTrigger fires callbacks when the trigger node is enabled or the trigger node position has changed.
WorldTrigger fires callbacks when any node (collider or not) gets inside or outside of it.
PhysicalTrigger fires callbacks when physical objects get inside or outside of it.

Here is a simple WorldTrigger usage example:

Source code (C#)

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{	
		// implement the enter callback
        void enter_callback(Node node)
        {
			Log.Message("\nA node named {0} has entered the trigger\n", node.Name);
        }
		// implement the leave callback
        void leave_callback(Node node)
        {
			Log.Message("\nA node named {0} has left the trigger\n", node.Name);
        }

		WorldTrigger trigger;
		int enter_callback_id;
		
        public override bool Init()
        {
            // create a world trigger
            trigger = new WorldTrigger(new vec3(3.0f));
            // add the enter callback to be fired when a node enters the world trigger
			//and keep its id to be used to remove the callback when necessary
            enter_callback_id = trigger.AddEnterCallback(enter_callback);
			// add the leave callback to be fired when a node leaves the world trigger
            trigger.AddLeaveCallback(leave_callback);

            return 1;
        }
	}
}

To remove the callbacks use the following code:

Source code (C#)

// remove the callback by using its id
trigger.RemoveEnterCallback(enter_callback_id);
// clear all leave callbacks
trigger.ClearLeaveCallbacks();

Body.AddFrozenCallback() to track an event when a body freezes.
Body.AddPositionCallback() to track an event when a body changes its position.
Body.AddContactCallback() to track an event when a body collides with another body or collidable surface.
Joint.AddBrokenCallback() to track an event when a joint breaks.

The following sample shows the way of registering callbacks for a BodyRigid and change the color of a mesh depending on its state:

Source code (C#)

// create a box static mesh
Mesh mesh = new Mesh();
mesh.AddBoxSurface("box_0", new vec3(1.0f));
ObjectMeshStatic node = new ObjectMeshStatic(mesh);
node.SetMaterial("mesh_base", "*");
node.Position = new dvec3(0, 0, 5.0f);

// add a rigid body
BodyRigid body = new BodyRigid(node);

// register callbacks for events by using lambdas
body.AddFrozenCallback(b => b.GetObject().SetMaterialParameterFloat4("albedo_color", new vec4(1.0f, 0.0f, 0.0f, 1.0f), 0));
body.AddPositionCallback(b => b.GetObject().SetMaterialParameterFloat4("albedo_color", new vec4(0.0f, 0.0f, 1.0f, 1.0f), 0));
body.AddContactCallback((b, num) => b.GetObject().SetMaterialParameterFloat4("albedo_color", new vec4(1.0f, 1.0f, 0.0f, 1.0f), 0));

// add a shape to the body
ShapeBox shape = new ShapeBox(body, new vec3(1.0f));

Notice

Physics-based callbacks are executed in parallel with the main tread, so you should not modify nodes inside these functions. If you want to reposition, transform, create or delete nodes captured by your callback function, you can store them in the array and then perform all necessary operations in the update(). See the example for contact callbacks

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{	
		// implement the enabled callback
        void node_property_added(Node n, Property property)
        {
			Log.Message("Property \"{0}\" was added to the node named \"{1}\".\n", property.Name, n.Name);
			// ...
        }

		Node node;
		
        public override bool Init()
        {
			// somewhere in the code

			Properties properties = Engine.properties;

			// inheriting a new property named "my_prop" from the base property "node_base"
			properties.FindManualProperty("node_base").Inherit("my_prop");

			// setting our callback function on adding a node property
			node.AddCallback(Node.CALLBACK_PROPERTY_NODE_ADD, node_property_added);

			// adding the property named "my_prop" to the node
			node.AddProperty("my_prop");

            return true;
        }
	}
}

You can add callbacks to track any changes made to a property and its parameters and perform certain actions.

The example below shows how to add a callback to track changes of property parameters and report the name of the property and the changed parameter (suppose we have a manual property named my_prop with an integer parameter named my_int_param).

Source code (C#)

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{	
		// implement the parameter changed callback
        void parameter_changed(Property property, int num)
        {
			Log.Message("Parameter \"{0}\" of the property \"{1}\" has changed its value.\n", property.GetParameterPtr(num).Name, property.Name);
			// ...
        }

        public override bool Init()
        {
			// somewhere in the code

			// getting a manual property named "my_prop" via the Property Manager
			Property property = Properties.FindManualProperty("my_prop");

			// setting our callback function on parameter change
			property.AddCallback(Property.CALLBACK_PARAMETER_CHANGED, parameter_changed);

			// changing the value of the "my_int_param" parameter
			property.SetParameterInt(property.FindParameter("my_int_param"), 3);

            return true;
        }
	}
}

You can also add callbacks to the Properties manager to track any changes made to any property and perform certain actions:

Source code (C#)

public void property_removed(Property property)
{
	Log.Message("Property \"{0}\" was removed.\n", property.getName());
    // ...
}

// somewhere in the code

Properties properties = Engine.properties;

// inheriting a new property named "my_prop" from the base property "surface_base"
Property property = properties.FindManualProperty("surface_base").Inherit("my_prop");

// setting our callback function on property removal
properties.AddCallback(Properties.CALLBACK_REMOVED, property_removed);

// removing the property named "my_prop"
properties.RemoveProperty(properties.FindProperty("my_prop").GetGUID());

These are not all usage examples of event handling callbacks. The following list contains more API members supporting event handling:

UserInterface - for handling events from widgets created by loading a UI file.
Render - callback functions can be used to get access to buffers and matrices at intermediate stages of the rendering sequence.
Console supports adding a callback function that will be executed when a text is output to the console.
EditorLogic - a set of editor callback functions can be overridden for certain purposes.
ComponentBase - there may be performed certain actions on destroying a component.
AsyncQueue - сallback functions can be used to determine actions to be performed when certain resources are loaded.
WorldSplineGraph provides a set of callbacks for handling actions on editing points and segments.
Viewport - callback functions can be used to get access to buffers and matrices at intermediate stages of the rendering sequence.

Plugins:

In This Article:

Practical Use#

Triggers#

See Also

Widgets#

See Also

Physics#

See Also

Properties#

See Also#