UnigineEditor
Interface Overview
Assets Workflow
Settings and Preferences
Adjusting Node Parameters
Setting Up Materials
Setting Up Properties
Landscape Tool
Using Editor Tools for Specific Tasks
FAQ
Programming
Fundamentals
Setting Up Development Environment
Usage Examples
UnigineScript
C++
C#
UUSL (Unified UNIGINE Shader Language)
File Formats
Rebuilding the Engine and 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
CIGI Client Plugin
Rendering-Related Classes

Processing User-Defined Packets

Simulations often require extended communication, which is not covered by standard packets included in a certain communication standard or protocol (DIS, CIGI, etc.). So, custom (user-defined) packets are needed.

Such custom packets make it possible to extend basic functionality and add more flexibility to the system (e.g. when you need to display some avionics data).

UNIGINE IG enables you to define and process custom (user-defined) packets. The workflow is simple and similar for all communication protocols:

  • Set a callback on receiving a certain packet. When IG receives a packet from the network, it creates an object of the appropriate class and passes it to the callback function.
  • Inside the callback function, read and interpret the data of the class instance passed to it (depending on what was written to the packet on the host).
  • Create and send a corresponding response packet, if necessary.

User-Defined CIGI Packets#

Just like with all other types of packets, to receive user-defined ones, we should add a callback for CIGI_OPCODE >= 201 (in accordance with CIGI ICD). On receiving such a packet, the callback shall be executed with ICigiHostUserDefined * packet passed to it.

The ICigiHostUserDefined class has the getData() method, which returns a set of bytes to be read and interpreted by the user (depending on what was written to the packet on the host).

The same situation is with sending packets. First, we ask the CIGIConnector to create a packet with a certain CIGI_OPCODE. If the code is equal to 201 or greater, an ICigiIGUserDefined instance shall be returned. You can set bytes to be sent by calling the ICigiIGUserDefined::setData() method.

Notice
Bytes are read and written starting from the 2nd byte (not from the 4th). If you want to align bytes starting from the 4th one, you should add a couple of bytes in the beginning. The CIGI ICD recommends to start reading/writing bytes starting from the 4th one (see Data before the Data Block 1 shown in the images below), although it is mentioned, that it is possible to start from the 2nd.

General User-Defined Packet Structure

Below is an example of working with user-defined CIGI packets:

Source code (C++)
int AppWorldLogic::init()
{
	// ....

	int index = Engine::get()->findPlugin("CIGIConnector");
	// check CIGIConnector plugin load
	if (index != -1)
	{

		// getting the CIGI interface
		cigi = (IG::CIGI::ConnectorInterface*)Engine::get()->getPluginData(index);
               // adding a calback for OPCODE = 202
		cigi->setReceivePacketCallback(202, MakeCallback(this, &AppWorldLogic::on_recv_user_packet));
	}
	return 1;
}

// ....

void AppWorldLogic::on_recv_user_packet(IG::CIGI::ICigiHostUserDefined * packet)
{
	Log::error("AppWorldLogic::on_recv_user_packet\n");
	unsigned char * request_data = packet->getData();  // read
	// ... 
        // creating a new IG user packet with opcode 203
	ICigiIGPacket * response_packet = cigi->createIGPacket(203);
	ICigiIGUserDefined * user_defined = dynamic_cast < ICigiIGUserDefined *>(response_packet);

	user_defined->setData(response_data, size_of_data); // write
	cigi->addIGPacket(response_packet);
}

Custom DIS PDU's#

In case of using DIS, custom Protocol Data Units (PDU's) are processed the same way as user-defined CIGI packets.

Notice
Basic level of DIS support is implemented using the KDIS library v2.9.0, DIS_VERSION 7, so don't forget to download it from here and add an additional include directory in your project to the KDIS/include/ folder.

Below is an example of working with custom PDU's:

Source code (C++)
#include <PDU/Header.h>
#include <DataTypes/EntityType.h>
#include <PDU/Entity_Info_Interaction/Entity_State_PDU.h>

// ...

int AppWorldLogic::init()
{
	// ....

	int index = Engine::get()->findPlugin("DISConnector");
	
	// check DISConnector plugin load
	if (index != -1)
	{
		// getting the DIS interface
		dis = (IG::DIS::ConnectorInterface*)Engine::get()->getPluginData(index);
        // adding a callback for all packets
		dis->setCallbackOnRecvPacket(MakeCallback(this, &AppWorldLogic::on_recv_packet));
	}
	return 1;
}

// ....

void AppWorldLogic::on_recv_packet(KDIS::PDU::Header *pdu)
{
	if (pdu->GetPDUType() == KDIS::DATA_TYPE::ENUMS::Entity_State_PDU_Type)
	{
		KDIS::PDU::Entity_State_PDU *entity_state_pdu = static_cast<KDIS::PDU::Entity_State_PDU *<(pdu);
		
		auto location = entity_state_pdu->GetEntityLocation();
		auto linear_velocity = entity_state_pdu->GetEntityLinearVelocity();
		auto appearance = entity_state_pdu->GetEntityAppearance();
		// ...
	}
	else if (pdu->GetPDUType() == KDIS::DATA_TYPE::ENUMS::Other_PDU_Type)
	{
		// ...
	}
}

Last update: 2019-11-28