Intersections

To find the intersection of nodes with bounds of the specified volume, you should use these 2 functions:

• engine.world.getIntersectionNodeVariables() to find all the nodes (or specified type nodes) that intersect bounds of the specified volume: BoundBox, BoundFrustum, BoundSphere. This function finds nodes which have set user variables.
• engine.world.getIntersectionNodes() functions to find all the nodes (or nodes of specified type) in within a given bounding volume: BoundBox, BoundFrustum, BoundSphere.

These functions return the amount of found nodes as an integer value and save the data in the ret[] array which you can pass to the function as an argument.

The engine.world.getIntersection() function is 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.

This function detects intersection with surfaces (polygons) of mesh and terrain objects. 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.

The engine.world.getIntersection() function is overloaded and receives 4 or 5 arguments:

• vec3 p0 — the start point coordinates of the trace line.
• vec3 p1 — the end point coordinates of the trace line.
• int mask — the Intersection mask. Use the Intersection mask to find object only with the specified mask.
• int exclude[] — the list of objects IDs to exclude.

• variable v — The function returns an intersected object which is the nearest to the start point (p0). Information about the intersection will be presented in variable which you pass to the function as an argument:

  • 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.
  Notice

  Passing NULL instead of the intersection query object will perform fast intersection algorithm without the closest intersection point searching.

Thus, to exclude some objects you should use these methods:

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

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 Unigine::getPlayerMouseDirection() function from core/scripts/utils.h.
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 engine.physics.getIntersection() function returns an intersected object when the object intersects with the traced line.
4. 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, the index of the surface and the Shape class object. You can get all these fields by using getShape(), getPoint() and getSurface() functions

#include <core/scripts/utils.h>
/* ... */
int update {
	// define two vec3 coordinates
	vec3 p0,p1;
	// get the mouse direction from camera (p0) to the cursor pointer (p1)
	Unigine::getPlayerMouseDirection(p0,p1);
	
	// create the instance of the PhysicsIntersection object to save the result
	PhysicsIntersection intersection = new PhysicsIntersection();
	// create an instance for intersected object and check the intersection
	Object object = engine.physics.getIntersection(p0,p1,1,intersection);
	
	// if the intersection has occurred, change the parameter of the object's material
	if(object != NULL)
	{
		forloop(int i=0; object.getNumSurfaces())
		{
			object.setMaterialParameterFloat4("albedo_color", vec4(1.0f, 0.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: %s shape: %s surface: %i \n", typeinfo(intersection.getPoint()), typeinfo(shape.getType()), intersection.getSurface());
		}
	}
	return 1;
}
/* ... */

The following example shows how you can get the intersection point (vec3) of the cylinder between two points with an obstacle. In this example we specify a cylinder from the point of the camera (vec3 p0) to the point of the mouse pointer (vec3 p1) with the specified radius. The executing sequence is the following:

1. Define and initialize two points (p0 and p1) by using the Unigine::getPlayerMouseDirection() function from core/scripts/utils.h.
2. Create an instance of the GameIntersection class to get the intersection point coordinates.
3. Check if there is an intersection with an obstacle. The engine.game.getIntersection() function returns an intersected obstacle when the obstacle appears in the area of the cylinder.
4. After that GameIntersection instance gets the point of the nearest intersection point and you can get it by using the getPoint() function.

#include <core/scripts/utils.h>

/* ... */
int update {
	/* ... */
	// define two vec3 coordinates
	vec3 p0,p1;
	// get the mouse direction from camera (p0) to the cursor pointer (p1)
	Unigine::getPlayerMouseDirection(p0,p1);
	
	// create an instance of the GameIntersection class
	GameIntersection intersection = new GameIntersection();
	
	// try to get the intersection with an obstacle.
	// cylinder has radius 0.1f, intersection mask equals to 1
	Obstacle obstacle = engine.game.getIntersection(p0,p1,0.1f, 1, intersection);
	
	// check if the intersection of mouse direction with any obstacle has occurred;
	if(obstacle !=NULL)
	{
		// show the coordinates of the intersection in console 
		log.message("The intersection with obstacle was here: %s\n", typeinfo(intersection.getPoint()));
	}
	return 1;
}
/* ... */