Intersections

To find the intersection of nodes with bounds of the specified volume, you should use functions that have a bounding volume and a vector of nodes in arguments:

• int getIntersection(WorldBoundBox bb, ICollection<Node> nodes)
• int getIntersection(WorldBoundSphere bs, ICollection<Node> nodes)
• int getIntersection(WorldBoundBox bb, int type, ICollection<Node> nodes)
• int getIntersection(WorldBoundSphere bs, int type, ICollection<Node> nodes)
• int getIntersection(WorldBoundFrustum bf, int type, ICollection<Node> nodes)

These functions return the value indicating the result of the intersection search: 1 if the intersection was found; otherwise, 0. Intersected nodes can be found in the collection that passed as an argument to the function.

To clarify the nodes search, perform the following:

• Specify the type of node to search.

Usage Example

// AppWorldLogic.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
		// define a bounding box
		WorldBoundBox boundBox;
		// create a counter to show the message once
		int counter = 1;

		public override bool Init()
		{
			// initialize the bounding box
			boundBox = new WorldBoundBox(new dvec3(0.0f), new dvec3(10.0f));
			return true;
		}

		public override bool Update()
		{
			// check the intersection with the bounding box
			World world = Engine.world;
			List<Node> nodes = new List<Node>();
			bool result = world.GetIntersection(boundBox, nodes);
			if (result && counter !=0)
			{
				foreach(Node n in nodes)
				{
					// show the name of the intersected node in the console
					Log.Message("There was an intersection with: {0} \n", n.Name);
				}
				counter--;
			}
			return true;
		}

		/* ... */
	}
}

The following functions can be used to perform the intersection search with objects:

• int getIntersection(Vec3 p0, Vec3 p1, ICollection<Object> objects)
• int getIntersection(WorldBoundBox bb, ICollection<Object> objects)
• int getIntersection(WorldBoundSphere bs, ICollection<Object> objects)
• int getIntersection(WorldBoundFrustum bf, ICollection<Object> objects)

These functions return the value indicating the result of the intersection search: 1 if the intersection was found; otherwise, 0. You can pass the start (vec3 p0) and the end (vec3 p1) point of the intersecting line or pass the (BoundBox, BoundFrustum, BoundSphere) to get the intersection of objects with a line or with a bounding volume, respectively. Intersected nodes can be found in the collection that passed as an argument to the function.

Usage Example

// AppWorldLogic.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
		// define a bounding box
		WorldBoundBox boundBox;
		// create a counter to show the message once
		int counter = 1;

		public override bool Init()
		{
			// initialize the bounding box
			boundBox = new WorldBoundBox(new dvec3(0.0f), new dvec3(10.0f));
			return true;
		}

		public override bool Update()
		{
			// check the intersection with the bounding box
			World world = Engine.world;
			List<Unigine.Object> objects = new List<Unigine.Object>();
			bool result = world.GetIntersection(boundBox, objects);
			if (result && counter != 0)
			{
				foreach (Unigine.Object o in objects)
				{
					Log.Message("There was an intersection with: {0} \n", o.Name);
				}
				counter--;
			}
			return true;
		}

		/* ... */
	}
}

The following functions are used to find the nearest intersected object with the traced line. You should specify the start point and the end point of the line, and the function detects if there are any object on the way of this line.

• Object getIntersection(Vec3 p0, Vec3 p1, int mask, Vec3[] ret_point, vec3[] ret_normal, vec4[] ret_texcoord, int[] ret_index, int[] ret_surface)
• Object getIntersection(Vec3 p0, Vec3 p1, int mask, Node[] exclude, Vec3[] ret_point, vec3[] ret_normal, vec4[] ret_texcoord, int[] ret_index, int[] ret_surface)
• Object getIntersection(Vec3 p0, Vec3 p1, int mask, WorldIntersection v)
• Object getIntersection(Vec3 p0, Vec3 p1, int mask, WorldIntersectionNormal v)
• Object getIntersection(Vec3 p0, Vec3 p1, int mask, WorldIntersectionTexCoord v)
• Object getIntersection(Vec3 p0, Vec3 p1, int mask, Node[] exclude, WorldIntersection v)
• Object getIntersection(Vec3 p0, Vec3 p1, int mask, Node[] exclude, WorldIntersectionNormal v)
• Object getIntersection(Vec3 p0, Vec3 p1, int mask, Node[] exclude, WorldIntersectionTexCoord v)

These functions return an intersection information and a pointer to the nearest object to the start point (p0). Information about the intersection can be presented in standard vectors or in the following format that you pass to functions as arguments:

• WorldIntersection intersection - the WorldIntersection class instance. By using this class you can get the intersection point (coordinates), the index of the intersected triangle of the object and the index of the intersected surface.
• WorldIntersectionNormal normal - the WorldIntersectionNormal class instance. By using this class you can get only the normal of the intersection point.
• WorldIntersectionTexCoord texcoord - the WorldIntersectionTexCoord class instance. By using this class you can get only the texture coordinates of the intersection point.

These functions detect intersection with surfaces (polygons) of meshes. But there are some conditions to detect the intersection with the surface:

1. The surface is enabled.
2. The surface has a material assigned.
3. Per-surface Intersection flag is enabled.
   Notice

   You can set this flag to the object's surface by using the Object.setIntersection() function.

To clarify the object search, perform the following:

• Use an intersection mask. An intersection is found only if an object is matching the intersection mask.
• Specify the list of objects (nodes) to exclude and pass to the function as an argument.

Usage Example

// AppWorldLogic.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
		// define world intersection instance
		WorldIntersection wi;
		// create a counter to show the message once
		int counter = 1;

		public override bool Init()
		{
			// initialize the world intersection
			wi = new WorldIntersection();
			return true;
		}

		public override bool Update()
		{
			// check the intersection with the bounding box
			World world = Engine.world;
			Unigine.Object o = world.GetIntersection(new dvec3(0.0f), new dvec3(1.0f), 1, wi);
			if (o != null && counter != 0)
			{
				Log.Message("The name of the obstacle is: {0} \n", o.Name);
				counter--;
			}
			return true;
		}

		/* ... */
	}
}

The following example shows how you can get the intersection information by using the PhysicsIntersection class. In this example we specify a line from the point of the camera (vec3 p0) to the point of the mouse pointer (vec3 p1). The executing sequence is the following:

1. Define and initialize two points (p0 and p1) by using the Player.getDirectionFromScreen() function.
2. Create an instance of the PhysicsIntersection class to get the intersection information.
3. Check, if there is an intersection with an object with a shape or a collision object. The getIntersection() function returns an intersected object when the object intersects with the traced line.
4. In this example, when the object intersects with the traced line, all the surfaces of the intersected object change their material parameters. If the object has a shape, its information will be shown in console. The PhysicsIntersection class instance gets the coordinates of the intersection point and the Shape class object. You can get all these fields by using getShape(), getPoint() functions.

// AppWorldlogic.cs

using Unigine;

#if UNIGINE_DOUBLE
    using Vec3 = Unigine.dvec3;
    using Vec4 = Unigine.dvec4;
    using Mat4 = Unigine.dmat4;
#else
    using Vec3 = Unigine.vec3;
    using Vec4 = Unigine.vec4;
    using Mat4 = Unigine.mat4;
#endif

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
		ObjectMeshDynamic dynamic_mesh;
		
		public override bool Init()
		{

            // create a mesh instance with a box surface
            Mesh mesh = new Mesh();
            mesh.AddBoxSurface("box", new vec3(2.2f));
            
            // create a new dynamic mesh from the Mesh instance and add it to editor
            dynamic_mesh = new ObjectMeshDynamic(mesh);

            // assign a material to the dynamic mesh
            dynamic_mesh.WorldTransform = MathLib.Translate(new Vec3(0.0f, 0.0f, 2.0f));
            dynamic_mesh.SetMaterial("mesh_base", "*");

            // assign a body and a shape to the dynamic mesh
            BodyRigid body = new BodyRigid(dynamic_mesh);
            ShapeBox shape = new ShapeBox(body, new vec3(2.2f));

			return true;
		}

		public override bool Update() {

			// initialize points of the mouse direction
			Vec3 p0, p1;

			// get the current player (camera)
			Player player = Game.Player;
			if (player == null)
				return false;
			// get width and height of the current application window
			int width = App.getWidth();
			int height = App.getHeight();
			// get the current X and Y coordinates of the mouse pointer
			int mouse_x = App.getMouseX();
			int mouse_y = App.getMouseY();
			// get the mouse direction from the player's position (p0) to the mouse cursor pointer (p1)
			player.GetDirectionFromScreen(out p0, out p1, mouse_x, mouse_y, width, height);

			// create the instance of the PhysicsIntersection object to save the information about the intersection
			PhysicsIntersection intersection = new PhysicsIntersection();
			// get an intersection
			Unigine.Object obj = Physics.GetIntersection(p0, p1, 1, intersection);

			// if the intersection has been occurred, change the parameter of the object's material    
			if (obj != null)
			{
				for (int i = 0; i < obj.NumSurfaces; i++)
				{
					obj.SetMaterialParameterFloat4("albedo_color", new vec4(1.0f, 1.0f, 0.0f, 1.0f), i);
				}

				// if the intersected object has a shape, show the information about the intersection   
				Shape shape = intersection.GetShape();
				if (shape != null)
				{
					Log.Message("physics intersection info: point: ({0} {1} {2}) shape: {3}\n", intersection.Point.x, intersection.Point.y, intersection.Point.z, shape.GetType());
				}
			}

			return true;
		}
	}
}

In the example below, the engine checks intersections with a obstacle box and shows the message in the console.

In the init() function the obstacle box is initialized.

The main logic is in the update() method: the engine checks the intersection and shows the message about the intersection.

// AppWorldLogic.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
		// define an obstacle box and game intersection instance
		ObstacleBox obstacleBox;
		GameIntersection gi;
		// create a counter to show the message once
		int counter = 1;

		public override bool Init()
		{
			// initialize the obstacle box and specify the name
			obstacleBox = new ObstacleBox(new vec3(1.0f));
			obstacleBox.Name = "main_obstacle";
			// initialize the game intersection object
			gi = new GameIntersection();
			return true;
		}

		public override bool Update()
		{
			// check the intersection with the obstacle box
			Game game = Engine.game;
			Obstacle obstacle = game.GetIntersection(new dvec3(0.0f), new dvec3(3.0f), 5.0f, 1, gi);
			if (obstacle.checkPtr() != null && counter != 0)
			{
				Log.Message("The name of the obstacle is: {0} \n", obstacle.Name);
				counter--;
			}
			return true;
		}

		/* ... */
	}
}