Creating Routes within Connected Navigation Sectors

The created navigation sectors only provide the area within which routes are calculated. The routes themselves should be created from the code. So, let's create the corresponding C# component for 2D route calculation:

1. Create the components folder in the data directory of your project: right-click in the Asset Browser and select Create Folder.
2. In the created folder, create a new component: right-click and select Create Code → C# Component and specify a name for the component.

   

3. Open the component in IDE to implement pathfinding logic.

1. Declare component parameters:
   • Two parameters that will accept nodes between which a route should be calculated.
   • Route color.
   Source code (C#)

   public class Route2D : Component
   {
   	// a node that will serve as a start point
   	public Node startPoint = null;
   	// a node that will serve as a destination point
   	public Node finishPoint = null;
   
   	// route color 
   	[ParameterColor]
   	public vec4 routeColor = vec4.ZERO;
   
   	// ....
   }

2. Create a route and set the radius and height that required to move the point along the route in the Init() method. Before creation, check if the nodes to be used as the start and finish points are specified.
   Notice

   Choosing the radius and height values is essential. If the height or radius exceeds the size of the sector or the intersection area, such sector/area will be excluded from pathfinding. To address this, you can modify the route parameters or adjust the size of the sector or intersection area.
   Source code (C#)

   // a route
   private PathRoute route = null;
   
   private void Init()
   {
   	// check if the start and destination nodes are correctly specified via the component interface
   	if (startPoint && finishPoint)
   	{
   		// create a new route
   		route = new PathRoute();
   
   		// set a radius and height for the point which will move along the route
   		route.Radius = 0.1f;
   		route.Height = 0.1f;
   	}
   }

3. To enable displaying the calculated route at run time, turn on Visualizer. Additionally, you can output console messages to the application screen. Add the following logic to the Init() function:
   Source code (C#)

   // enable the onscreen console messages to display info on route calculation
   Unigine.Console.Onscreen = true;
   // enable visualization of the calculated route
   Visualizer.Enabled = true;

4. In the Update() function, calculate the route from the start to destination node:
   Source code (C#)

   private void Update()
   {
   	// check if the start and destination nodes are correctly specified via the component interface
   	if (startPoint && finishPoint)
   	{
   		// calculate the path from the start to destination point
   		//  a destination point of the route is reached.
   		route.Create2D(startPoint.WorldPosition, finishPoint.WorldPosition);
   		if (route.IsReached)
   		{
   			// if the destination point is reached, render the root in a specified color
   			if (visualizeRoute)
   				route.RenderVisualizer(routeColor);
   		}
   		else
   			Log.Message($"{node.Name} PathRoute not reached yet\n");
   	}
   }

   Notice

   Here the route is recalculated each frame. However, it is not optimal for application performance. Instead, you can calculate the route once per several frames: pass a delay to the create2D() function as the third argument.
5. Implement the Shutdown() function to disable the visualizer and onscreen console messages:
   Source code (C#)

   private void Shutdown()
   {
   	Unigine.Console.Onscreen = false;
   	Visualizer.Enabled = false;
   }

Here the full code of the component:

using Unigine;

[Component(PropertyGuid = "ec10a5720354c62988b25974f975b6439a92e6c6")]
public class Route2D : Component
{
	public Node startPoint = null;
	public Node finishPoint = null;

	public bool visualizeRoute = false;

	[ParameterColor]
	public vec4 routeColor = vec4.ZERO;

	private PathRoute route = null;

	private void Init()
	{
		if (startPoint && finishPoint)
		{
			route = new PathRoute();

			route.Radius = 0.1f;
			route.Height = 0.1f;

			Unigine.Console.Onscreen = true;
			Visualizer.Enabled = true;
		}
	}

	private void Update()
	{
		if (startPoint && finishPoint)
		{
			route.Create2D(startPoint.WorldPosition, finishPoint.WorldPosition);
			if (route.IsReached)
			{
				if (visualizeRoute)
					route.RenderVisualizer(routeColor);
			}
			else
				Log.Message($"{node.Name} PathRoute not reached yet\n");
		}
	}

	private void Shutdown()
	{
		Unigine.Console.Onscreen = false;
		Visualizer.Enabled = false;
	}
}

When the component logic is implemented, you should assign it to a node.

1. In UnigineEditor, select Create → Node → Dummy and place it in the navigation area.
2. Select the dummy node and assign the Route2D.cs component to it in the Parameters window.
3. In the component parameters, specify the start and finish static meshes in the Start Point and Finish Point fields.

   

4. Change the Route Color, if necessary.

1. In the components folder, create the AreaVisualizer component.
   Notice

   If you have completed the previous guide on creating routes within a simple navigation sector, you can skip this step and use the implemented AreaVisualizer component. Just copy it to the data/components folder of your project and assign it to all the navigation sectors forming the navigation area.
2. Implement rotation logic:
   Source code (C#)

   public class AreaVisualizer : Component
   {
   	private NavigationSector navigationSector = null;
   
   	private void Init()
   	{
   		// get the navigation sector to which the component is assigned
   		navigationSector = node as NavigationSector;
   		
   		// enable rendering of the visualizer
   		if (navigationSector)
   			Visualizer.Enabled = true;
   	}
   
   	private void Update()
   	{
   		// display the navigation area gizmo
   		if (navigationSector)
   			navigationSector.RenderVisualizer();
   	}
   
   	private void Shutdown()
   	{
   		// disable rendering of the visualizer
   		Visualizer.Enabled = false;
   	}
   }

3. Assign the component to each navigation sector forming the navigation area.

Click Run to run the component logic and check the result.

You can force the Route2D component to calculate a 3D route within the same navigation area by changing a single line of the code. Replace the route.Create2D() function call with the following:

route.Create3D(startPoint.WorldPosition, finishPoint.WorldPosition);