Unigine.NodeReference Class

The Automatic Unpacking mode defines where the content of NodeReferences is placed in the world nodes hierarchy when it is loaded at run time (at the world startup or when a new NodeReference is created). When enabled, the content of NodeReference is extracted to simplify hierarchy management. This is a global setting for all worlds used in your project.

// AppSystemLogic.cs

using Unigine;

namespace UnigineApp
{
	class AppSystemLogic : SystemLogic
	{
        public override bool Init()
		{
			// disable automatic unpacking before the world is loaded
			World.UnpackNodeReferences = false;

			return true;
		}
	}
}

The auto-unpacking mode affects the relation between the transformations of the NodeReference and the nodes stored by it.

Automatic Unpacking Disabled#

// AppWorldLogic.cs

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
        public override bool Init()
		{
            // create a NodeReference instance
            NodeReference nodeRef = new NodeReference("nodes/node_reference_0.node");

            // get the reference node
            Node group = nodeRef.Reference;

            // find the desired node
            Node node_2 = group.GetChild(group.FindChild("Node_2"));

			return true;
		}
	}
}

Automatic Unpacking Enabled#

// AppWorldLogic.cs

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
        public override bool Init()
		{
            // create a NodeReference instance
            NodeReference nodeRef = new NodeReference("nodes/node_reference_0.node");

            // get the root node of the pre-fabricated hierarchy
            Node group = nodeRef.GetChild(0);

            // find the desired node among all descendants
            Node node_2 = nodeRef.FindNode("Node_2", 1);

			return true;
		}
	}
}

Local transformation of the root node stored by NodeReference is not necessarily identity, it can be displaced relative to the NodeReference position, for example.

If automatic unpacking of NodeReference is enabled, the transformations of nodes are simply subject to parent-child relation. However, if automatic unpacking is disabled (i.e. the node content has been added to the root of world nodes hierarchy), matrix hierarchy is used for the content of the NodeReference. Thus, when moving the NodeReference, the root node of its content also moves relatively to this NodeReference. At that, the local transformation matrix of the root reference node changes.

This relation of transformations can be destroyed by detaching the reference node from the NodeReference instance. Note that the unpacked detached node will remain child of the NodeReference and its tranformation matrix will still be affected by the NodeReference transformation. In this case you may need to unparent the detached node by using setParent() method.

Each NodeReference has its internal copy of nodes loaded from the *.node asset and therefore this allows applying unique changes to each instance of identical NodeReferences separately at runtime (adding, deleting, and changing the nodes inside NodeReference).

Other NodeReference instances will not be updated at runtime when changes are applied to a single instance. If you want to propagate these changes at runtime from one instance of a NodeReference to all the other NodeReference in the world that are linked to the same *.node asset on disk, you should save changes to the asset and reload all NodeReferences. Automatic runtime reloading is available.

• Article on Nodes that lists the main differences between the regular nodes and reference nodes
• Article on Node Reference
• Node References: Must-Knows demonstrating the specifics of Node Reference

To create a NodeReference, you should specify a path to the existing *.node file. For example, you can export a node into a *.node file and then create a NodeReference by using it:

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{		
        public override bool Init()
		{
            // create a mesh
            Mesh mesh = new Mesh();
            mesh.AddBoxSurface("box_0", new vec3(1.0f));
            // create a dynamic mesh by using the mesh
            ObjectMeshDynamic dynamic = new ObjectMeshDynamic(mesh);
            // export the dynamic mesh into a *.node file
            World.SaveNode("unigine_project/nodes/node_reference_0.node", dynamic);
            // create a node reference
            NodeReference nodeRef = new NodeReference("unigine_project/nodes/node_reference_0.node");

			return true;
		}
	}
}

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{

        public void nodeCast(Node node)
        {

            // check if the node is a NodeReference
            if (node.Type == Node.Type.NODE_REFERENCE)
            {
                // cast the node to the NodeReference
                NodeReference nodeRef = node as NodeReference;
                // set a name for the NodeReference
                nodeRef.Name = "NodeReference_cast";
            }
        }

		public override bool Init()
		{

            // create a NodeReference from the file
            NodeReference nodeRef_0 = new NodeReference("unigine_project_10/nodes/node_reference_0.node");
            // set a name
            nodeRef_0.Name = "NodeReference_0";

            // save changes into the *.world file
            Unigine.Console.Run("world_save");
            // get the added NodeReference as a Node
            Node node = World.GetNodeByName("NodeReference_0");
            // cast the obtained Node to a NodeReference
            nodeCast(node);

			return true;
		}
	}
}

Editing a NodeReference includes:

• Changing the path to the referenced .node file.
• Editing the node stored by the reference.

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
        public override bool Init()
		{
            // create a NodeReference instance
            NodeReference nodeRef = new NodeReference("unigine_project_10/nodes/node_reference_0.node");
            // set a name
            nodeRef.Name = "NodeReference_0";

            // get a node stored by the reference and check if it is an ObjectMeshDynamic
            if (nodeRef.Reference.Type == Node.Type.OBJECT_MESH_DYNAMIC)
            {
                // cast the referenced node to the ObjectMeshDynamic type
                ObjectMeshDynamic dynamic = nodeRef.Reference as ObjectMeshDynamic;
                // save changes on the referenced node into the *.node file
                World.SaveNode(nodeRef.NodePath, dynamic);
            }

			return true;
		}
	}
}

As a result, the source *.node file, to which the NodeReference refers, will be updated and the NodeReference_0 node will refer to the updated node with the material assigned. If you want all NodeReferences that refer to the modifed *.node asset to update automatically, you should enable automatic reloading of NodeReferences by calling the setAutoReloadNodeReferences() method preliminarily.