This page has been translated automatically.
Video Tutorials
Interface
Essentials
Advanced
How To
UnigineEditor
Interface Overview
Assets Workflow
Settings and Preferences
Working With Projects
Adjusting Node Parameters
Setting Up Materials
Setting Up Properties
Lighting
Landscape Tool
Sandworm
Using Editor Tools for Specific Tasks
Extending Editor Functionality
Built-in Node Types
Nodes
Objects
Effects
Decals
Light Sources
Geodetics
World Objects
Sound Objects
Pathfinding Objects
Players
Programming
Fundamentals
Setting Up Development Environment
UnigineScript
C++
C#
UUSL (Unified UNIGINE Shader Language)
File Formats
Rebuilding the Engine Tools
GUI
Double Precision Coordinates
API
Containers
Common Functionality
Controls-Related Classes
Engine-Related Classes
Filesystem Functionality
GUI-Related Classes
Math Functionality
Node-Related Classes
Objects-Related Classes
Networking Functionality
Pathfinding-Related Classes
Physics-Related Classes
Plugins-Related Classes
IG Plugin
CIGIConnector Plugin
Rendering-Related Classes
Content Creation
Content Optimization
Materials
Art Samples
Tutorials
Warning! This version of documentation is OUTDATED, as it describes an older SDK version! Please switch to the documentation for the latest SDK version.
Warning! This version of documentation describes an old SDK version which is no longer supported! Please upgrade to the latest SDK version.

Intersections

Unigine has different methods to detect intersections. Intersection is a shared point of the defined area (or line) and an object. This article describes different types of intersections and their usage.

There are three main types of intersections:

Shape and Object classes have their own getIntersection() functions. They are used for detecting intersections with the specific shape or the specific surface of the object.

World Intersection#

By using different overloaded World class getIntersection() functions you can find objects and nodes that intersect bounds of the specified bounding volume or find the first intersection of the object with the invisible tracing line.

World class functions for intersection search can be divided into 3 groups:

Intersection with Nodes#

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:

Schematic visual representation of intersection with nodes in bounding volume.

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 vector 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

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

In the update() method: the engine checks the intersection and shows the message about intersection.

Source code (C++)
// AppWorldLogic.cpp
#include "AppWorldLogic.h"
#include "UnigineMathLib.h"
#include "UnigineWorld.h"

using namespace Unigine;
using namespace Unigine::Math;

/* ... */

int AppWorldLogic::update() {
	// initialize a bounding box and vector for intersected nodes
	WorldBoundBox boundBox(Vec3(0.0f), Vec3(1.0f));
	Vector<Ptr<Node>> nodes;

	// check the intersection with nodes
	int result =  World::getIntersection(boundBox, nodes);
	if (result)
	{
		for (int i = 0; i < nodes.size(); i++)
		{
			Log::message("Intersected node: %s \n", nodes.get(i)->getName());
		}
		Log::message("The number of intersected nodes is: %i \n", nodes.size());
	}

	return 1;
}

/* ... */

Intersection with Objects#

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

Schematic visual representation of intersection with objects in bounding volume.

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 vector that passed as an argument to the function.

Usage Example

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

In the update() method: the engine checks the intersection and shows the message about intersection.

Source code (C++)
// AppWorldLogic.cpp
#include "AppWorldLogic.h"
#include "UnigineMathLib.h"
#include "UnigineWorld.h"

using namespace Unigine;
using namespace Unigine::Math;

/* ... */

int AppWorldLogic::update() {
	// initialize a bounding box and vector for intersected objects
	WorldBoundBox boundBox(Vec3(0.0f), Vec3(1.0f));

	Vector<Ptr<Object>> objects;

	int result = World::getIntersection(boundBox, objects);
	if (result)
	{
		for (int i = 0; i < objects.size(); i++)
		{
			Log::message("Intersected node: %s \n", objects.get(i)->getName());
		}
		Log::message("The number of intersected nodes is: %i \n", objects.size());
	}

	return 1;
}

/* ... */
Usage Example 2#

In the example below, the engine checks intersections of a world bound frustrum with objects which are invisible because they are out of their maximum visible distance. To do so, it is required to set the global distance scale parameter to infinite value. This will make invisible objects appear and be detected by the intersection. Then we need to restore the previous distance scale value right away to avoid surfaces popping out in the next frame.

Source code (C++)
// AppWorldLogic.cpp
#include "AppWorldLogic.h"

#include <UnigineObjects.h>
#include <UnigineVisualizer.h>
#include <UnigineInput.h>
#include <UniginePlayers.h>
#include <UnigineGame.h>
#include <UnigineWorld.h>

using namespace Unigine;
using namespace Math;

bool inf_scale = false;

int AppWorldLogic::init()
{
	Visualizer::setEnabled(true);

	return 1;
}

int AppWorldLogic::update()
{
	// turn on and off the intersection detection for invisible objects
	if (Input::isKeyDown(Input::KEY_SPACE))
		inf_scale = !inf_scale;

	// get a reference to the camera
	PlayerPtr player = Game::getPlayer();
	CameraPtr camera = player->getCamera();

	// bound frustrum for the intersection and a list to store intersected objects
	WorldBoundFrustum bf(camera->getProjection(), camera->getModelview());
	Vector<ObjectPtr> objects;

	// remember the old distance scale
	float old_ds = Render::getDistanceScale();

	// set the global distance scale to infinity
	if (inf_scale)
		Render::setDistanceScale(Consts::INF);

	// perform the intersection search with the bound frustrum
	World::getIntersection(bf, objects);

	// draw the bound spheres of all objects' surfaces found by the search
	for (int i = 0; i < objects.size(); i++) 
	{
		for (int j = 0; j < objects[i]->getNumSurfaces(); j++)
		{
			float d = objects[i]->getMaxVisibleDistance(j);
			if (d != Consts::INF)
			{
				BoundSphere bs = objects[i]->getBoundSphere(j);
				Visualizer::renderBoundSphere(bs, objects[i]->getWorldTransform(), vec4_red);
				break;
			}
		}
	}

	// reset the distance scale to the old value
	Render::setDistanceScale(old_ds);

	return 1;
}

By default, the intersection with a camera-based bounding frustrum uses the global distance scale. To make more objects get inside the camera frustrum, just increase the global distance scale.

First Intersected Object#

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.

Schematic visual representation of intersection with objects and traced line.

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

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

In the update() method: the engine checks the intersection and shows the message about intersection.

Source code (C++)
// AppWorldLogic.cpp
#include "AppWorldLogic.h"
#include "UnigineMathLib.h"
#include "UnigineWorld.h"

using namespace Unigine;
using namespace Unigine::Math;

/* ... */

int AppWorldLogic::update() {
	WorldIntersectionPtr wi =  WorldIntersection::create();
	ObjectPtr o;

	if (wi)
		o = World::getIntersection(Vec3(0.0f), Vec3(1.0f), 1, wi);

	if (o)
	{
		Log::message("Intersected object is: %s \n", o->getName());
	}
	return 1;
}

/* ... */

Physics Intersection#

Physics intersection function detects intersections with a physical shape or a fracture body. If the object has no body, this function detects intersection with surfaces (polygons) of the object having the physics intersection flag enabled. When you need to find the intersection with the shape of the object (not with polygons), the intersection function of Physics class is the best way to get it.

The picture above shows how the getIntersection() function detects the shape that intersects with the line.

There are 4 functions to find physics intersections:

These functions perform tracing from the start p0 point to the end p1 point to find a collision object (or a shape) located on that line. Functions use world space coordinates.

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

  • Use a physics intersection mask. A physics intersection is detected only if the physics intersection mask of the surface/shape/body matches the intersection mask passed as a function argument, otherwise it is ignored.
  • Specify the list of objects to exclude and pass to the function as an argument.

Usage Example

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.
Source code (C++)
// AppWorldLogic.cpp
#include <UnigineEditor.h>
#include <UniginePhysics.h>
#include <UnigineGame.h>
#include <UnigineApp.h>
#include <UnigineObjects.h>

using namespace Unigine;
using namespace Math;

ObjectMeshDynamicPtr dynamic_mesh;

int AppWorldLogic::init() {
	
	// create a mesh instance with a box surface
	MeshPtr mesh = Mesh::create();
	mesh->addBoxSurface("box", vec3(0.2f));

	// create a new dynamic mesh from the Mesh instance and add it to editor
	dynamic_mesh = ObjectMeshDynamic::create(mesh);

	// assign a material to the dynamic mesh
	dynamic_mesh->setWorldTransform(translate(Vec3(0.0f, 0.0f, 2.0f)));
	dynamic_mesh->setMaterial("mesh_base", "*");

	// assign a body and a shape to the dynamic mesh
	BodyRigidPtr body = BodyRigid::create(dynamic_mesh);
	ShapeBoxPtr shape = ShapeBox::create(body, vec3(0.2f));

	return 1;
}

// start of the main loop
int AppWorldLogic::update() {
	
	// initialize points of the mouse direction
	Vec3 p0, p1;

	// get the current player (camera)
	PlayerPtr player = Game::getPlayer();
	if (player.get() == NULL)
		return 0;
	// 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(p0, p1, mouse_x, mouse_y, width, height);

	// create the instance of the PhysicsIntersection object to save the information about the intersection
	PhysicsIntersectionPtr intersection = PhysicsIntersection::create();
	// get an intersection
	ObjectPtr object = Physics::getIntersection(p0, p1, 1, intersection);

	// if the intersection has been occurred, change the parameter of the object's material    
	if (object)
	{
		for (int i = 0; i < object->getNumSurfaces(); i++)
		{
			object->setMaterialParameterFloat4("albedo_color", vec4(1.0f, 1.0f, 0.0f, 1.0f), i);
		}

		// if the intersected object has a shape, show the information about the intersection   
		ShapePtr shape = intersection->getShape();
		if (shape)
		{
			Log::message("physics intersection info: point: (%f %f %f) shape: %s\n", intersection->getPoint().x, intersection->getPoint().y, intersection->getPoint().z, typeid(shape->getType()).name());
		}
	}

	return 1;
}

Game Intersection#

Game class getIntersection() functions are used to check the intersection with obstacles (pathfinding nodes):

The engine creates an invisible cylinder with specified radius between two points and checks if an obstacle is presented inside of it.

Schematic visual representation of intersection with objects and cylinder volume.

These functions return an intersection information and a pointer to the nearest obstacle to the start point (p0). Information about the intersection will be presented in the GameIntersection class instance which you pass to the function as an argument or in the vector.

Use mask and exclude arguments of the overloaded function to specify the obstacle search.

To clarify the obstacle search, perform the following:

  • Use an obstacle intersection mask. An intersection is found only if an object is matching the intersection mask, otherwise it is ignored.
  • Specify the list of obstacles to exclude and pass to the function as an argument.

Usage Example

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. Create an instance of the ObstacleBox class on the application initialization.
  2. Define and initialize two points (p0 and p1) by using the Player::getDirectionFromScreen() function.
  3. Create an instance of the GameIntersection class to get the intersection point coordinates.
  4. Check, if there is an intersection with an obstacle. The Game::getIntersection() function returns an intersected obstacle when the obstacle appears in the area of the cylinder.
  5. After that GameIntersection instance gets the point of the nearest intersection point and you can get it by using the getPoint() function.
Source code (C++)
// AppWorldLogic.cpp

#include <UnigineEditor.h>
#include <UnigineGame.h>
#include <UnigineApp.h>
#include <UnigineObjects.h>
#include <UniginePathFinding.h>

using namespace Unigine;
using namespace Math;

int AppWorldLogic::init() {
	
	// create a mesh instance with a box surface
	MeshPtr mesh = Mesh::create();
	mesh->addBoxSurface("box", vec3(1.0f));
	
	// create a new dynamic mesh from the Mesh instance and add it to editor
	ObjectMeshDynamicPtr dynamic_mesh = ObjectMeshDynamic::create(mesh);

	// assign a material to the dynamic mesh
	dynamic_mesh->setWorldTransform(translate(Vec3(0.0f, 0.0f, 2.0f)));
	dynamic_mesh->setMaterial("mesh_base", "*");
	
	// create an obstacle
	ObstacleBoxPtr obstacle = ObstacleBox::create(vec3(1.0f));

	// set the obstacle transformation so that it coincides with the dynamic mesh transformation
	obstacle->setWorldTransform(translate(Vec3(0.0f, 0.0f, 2.0f)));
	// add the obstacle as the child node to the dynamic mesh
	dynamic_mesh->addChild(obstacle->getNode());

	return 1;
}

// start of the main loop
int AppWorldLogic::update() {
	
	// initialize points of the mouse direction
	Vec3 p0, p1;

	// get the current player (camera)
	PlayerPtr player = Game::getPlayer();
	if (player.get() == NULL)
		return 0;
	// 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(p0,p1,mouse_x, mouse_y, width, height);

	// create an instance of the GameIntersection class
	GameIntersectionPtr intersection = GameIntersection::create();

	// try to get the intersection with an obstacle
	// cylinder has radius 1.5f, intersection mask equals to 1
	ObstaclePtr obstacle = Game::getIntersection(p0, p1, 1.5f, 1, intersection);

	// check, if the intersection of mouse direction with any obstacle was occurred;
	if (obstacle)
	{
		// show the coordinates of the intersection in console 
		Log::message("The intersection with the obstacle was here: (%f %f %f)\n", intersection->getPoint().x, intersection->getPoint().y, intersection->getPoint().z);
	}

	return 1;
}
Last update: 2021-08-24
Build: ()