Шаблон приложения IG

Unigine IG использует Interpolated Snapshots (IS) для решения проблемы потери пакетов между IG и хостами. Он работает, беря две старые, но известные позиции и интерполируя объект между ними. Это достигается за счет наличия буфера полученных позиций и поворотов, а также времени, которое они представляют. Обычно мы берем текущее местное время за вычетом некоторого предопределенного значения - период интерполяции ( 40 мс по умолчанию), затем заходим в наш буфер, находим два индекса, которые находятся непосредственно перед и сразу после этого времени и интерполировать.

Если у нас нет полученного положения и поворота для искомого времени, используется экстраполяция (предположение). Он также имеет ограниченное время - период экстраполяции (по умолчанию 200 мс). Если период экстраполяции закончился, но пакеты все еще не получены, все объекты «заморозятся».

В большинстве случаев этот метод обеспечивает очень точное представление мира для каждого ведомого устройства, так как обычно отображаются только уже известные положения удаленных объектов, а в редких случаях система пытается экстраполировать (угадывать), где находится объект. Однако за это приходится платить, так как мы всегда отображаем 40 мс (период интерполяции) от текущего времени, так что новые пакеты успевают прибыть с данными.

• Раздел IG plugin API для получения дополнительных сведений об управлении IG с помощью кода (C ++).
• В статье Настройка свойств для получения дополнительных сведений о настройке свойств для новых сущностей.
• В статье IG Configuration для получения дополнительных сведений о настройке IG.
• Подробнее о настройке параметров неба и погоды см. В статье Environment Settings .

Коннектор - это на самом деле настраиваемый плагин C ++ , используемый для передачи сообщений между хостом и IG. Этот плагин считывает пакеты и вызывает соответствующие методы IG Plugin (перечисленных в include / plugins / UnigineIG.h ).

Перечисленные ниже файлы можно использовать в качестве шаблона для вашего настраиваемого коннектора:

• Включаемый файл плагина, который нужно поместить в папку include/plugins:

  CUSTOMConnectorInterface.h

  Исходный код (C++)

  #ifndef __CUSTOM_CONNECTOR_INTERFACE_H__
  #define __CUSTOM_CONNECTOR_INTERFACE_H__
  
  namespace IG
  {
  	namespace CUSTOM
  	{
  		class ConnectorInterface
  		{
  		public:
  			virtual ~ConnectorInterface() {}
  			
  			// client initialization
  			virtual int init(/*initialization parameters*/) = 0;
  			// client shutdown
  			virtual int shutdown() = 0;
  			
  			// other methods
  			// ...
  			
  			// callbacks
  			//virtual void setConnectCallback(Unigine::CallbackBase* func) = 0;
  			//virtual Unigine::CallbackBase* getConnectCallback() const = 0;
  			// ...
  		};
  	}
  }
  
  #endif /* __CUSTOM_CONNECTOR_INTERFACE_H__ */

• Исходные файлы плагина, которые нужно поместить в папку source/custom_connector:

  CUSTOMConnectorPlugin.cpp

  Исходный код (C++)

  #include <UniginePlugin.h>
  
  #include "CUSTOMConnector.h"
  #include "CUSTOMConnectorInterpreter.h"
  
  using namespace Unigine;
  
  //////////////////////////////////////////////////////////////////////////
  // CUSTOMConnectorPlugin
  //////////////////////////////////////////////////////////////////////////
  
  class CUSTOMConnectorPlugin : public Plugin
  {
  public:
  	CUSTOMConnectorPlugin();
  	virtual ~CUSTOMConnectorPlugin();
  
  	const char *get_name() override;
  	void *get_data() override;
  
  	int init() override;
  	int shutdown() override;
  	void update() override;
  
  private:
  	IG::CUSTOM::Connector *connector;
  };
  
  CUSTOMConnectorPlugin::CUSTOMConnectorPlugin()
  	: connector(nullptr)
  {
  }
  
  CUSTOMConnectorPlugin::~CUSTOMConnectorPlugin()
  {
  	CUSTOMConnectorInterpreterShutdown();
  	delete connector;
  }
  
  const char *CUSTOMConnectorPlugin::get_name()
  {
  	return "CUSTOMConnector";
  }
  
  void *CUSTOMConnectorPlugin::get_data()
  {
  	return static_cast<IG::CUSTOM::ConnectorInterface *>(connector);
  }
  
  int CUSTOMConnectorPlugin::init()
  {
  	connector = new IG::CUSTOM::Connector();
  	connector->init();
  	CUSTOMConnectorInterpreterInit();
  	return 1;
  }
  
  int CUSTOMConnectorPlugin::shutdown()
  {
  	connector->shutdown();
  	return 1;
  }
  
  void CUSTOMConnectorPlugin::update()
  {
  	connector->update();
  }
  
  //////////////////////////////////////////////////////////////////////////
  // Plugin export
  //////////////////////////////////////////////////////////////////////////
  
  extern "C" UNIGINE_EXPORT void *CreatePlugin()
  {
  	return new CUSTOMConnectorPlugin();
  }
  
  extern "C" UNIGINE_EXPORT void ReleasePlugin(void *plugin)
  {
  	delete static_cast<CUSTOMConnectorPlugin *>(plugin);
  }

  CUSTOMConnector.h

  Исходный код (C++)

  #ifndef __CUSTOM_CONNECTOR_H__
  #define __CUSTOM_CONNECTOR_H__
  
  #include <plugins/CUSTOMConnectorInterface.h>
  #include <plugins/UnigineIG.h>
  #include <UnigineInterface.h>
  #include <UnigineLogic.h>
  
  namespace IG
  {
  namespace CUSTOM
  {
  	class CUSTOMWorldLogic;
  
  	class Connector : public ConnectorInterface
  	{
  	public:
  		Connector();
  		virtual ~Connector() {}
  		// singleton
  		static Connector *get() 
  		{
  			if (connector == nullptr)
  				Log::fatal("%s:: CUSTOM connector is NULL\n", __FUNCTION__);
  			return connector;
  		};
  
  		// automatic initialization on plugin load
  		void init();		
  
  		// update/shutdown client
  		void update();
  		void shutdown();
  		
  		// methods to be called by the CUSTOMWorldLogic class at the corresponding stages of the execution sequence
  		void onWorldInit();
  		void onWorldShutdown();
  	private:
  		static Connector *connector;
  		IG::Manager *ig_manager = nullptr;
  		CUSTOMWorldLogic *world_logic;
  	};
  	
  	// WorldLogic class
  	class CUSTOMWorldLogic : public Unigine::WorldLogic
  	{
  	public:
  		CUSTOMWorldLogic() {}
  		virtual ~CUSTOMWorldLogic() {}
  
  		virtual UNIGINE_INLINE int init() override { Connector::get()->onWorldInit(); return 1; }
  		virtual UNIGINE_INLINE int shutdown() override { Connector::get()->onWorldShutdown(); return 1; }
  	};
  }
  }
  
  #endif /* __CUSTOM_CONNECTOR_H__ */

  CUSTOMConnector.cpp

  Исходный код (C++)

  #include "CUSTOMConnector.h"
  #include <UnigineEngine.h>
  #include <UnigineNode.h>
  
  using namespace Unigine;
  using namespace Math;
  using namespace IG;
  using namespace CUSTOM;
  
  Connector::Connector() {
  	world_logic = new CUSTOMWorldLogic();
  	Engine::get()->addWorldLogic(world_logic);
  }
  
  void Connector::init()
  {
  	const auto host = "127.0.0.1";
  	const auto port = 3000;
  	
  	int ig_plugin_index = Engine::get()->findPlugin("IG");
  	if (ig_plugin_index == -1)
  	{
  		Log::error("IG::CUSTOM::Connector::init(): IG plugin isn't loaded\n");
  		return;
  	}
  	ig_manager = (IG::Manager*)Engine::get()->getPluginData(ig_plugin_index);
  	
  	// IG setup
  	ig_manager->setCoordinateSystem(IG::Manager::COORDINATE_SYSTEM::NED);
  	
  }
  
  void Connector::update()
  {
  	// read & write packets
  }
  
  void Connector::shutdown() 
  {
  	// shutdown client
  	shutdown();
  	
  	// clear static link
  	connector = nullptr;
  	
  	// ...
  }
  
  void Connector::onWorldInit() 
  {
  	// actions to be performed when a new world is loaded
  }
  
  void Connector::onWorldShutdown() 
  {
  	// actions to be performed when current world is closed
  }

  CUSTOMConnectorInterpreter.h

  Исходный код (C++)

  #ifndef __CUSTOM_CONNECTOR_INTERPRETER_H__
  #define __CUSTOM_CONNECTOR_INTERPRETER_H__
  
  #include <UnigineBase.h>
  
  void CUSTOMConnectorInterpreterInit();
  void CUSTOMConnectorInterpreterShutdown();
  
  #endif /* __CUSTOM_CONNECTOR_INTERPRETER_H__ */

  CUSTOMConnectorInterpreter.cpp

  Исходный код (C++)

  #include <UnigineEngine.h>
  #include <UnigineInterface.h>
  
  #include <plugins/CUSTOMConnectorInterface.h>
  #include "CUSTOMConnector.h"
  
  using namespace Unigine;
  using namespace IG;
  
  void CUSTOMConnectorInterpreterInit()
  {
  	int id = Interpreter::addGroup("CUSTOMConnectorInterpreter");
  
  	// defines
  	Interpreter::addExternDefine("HAS_CUSTOM_CONNECTOR", id);
  
  	// enums
  	// Interpreter::addExternVariable("CUSTOM_VERSION_10", MakeExternConstant<int>(CUSTOM_VERSION_10), id);
  
  	// functions
  	Connector *connector = Connector::get();
  	Interpreter::addExternLibrary("engine.custom", id);
  	//Interpreter::addExternFunction("engine.custom.init", MakeExternObjectFunction(connector, &Connector::init), id);
  	//Interpreter::addExternFunction("engine.custom.shutdown", MakeExternObjectFunction(connector, &Connector::shutdown), id);
  }
  
  void CUSTOMConnectorInterpreterShutdown()
  {
  	Interpreter::removeGroup("CUSTOMConnectorInterpreter");
  }

  CUSTOMConnectorWrapper.cpp

  Исходный код (C++)

  //push ignore deprecated warnings
  #ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  #elif defined(_MSC_VER)
  #pragma warning(push)
  #pragma warning(disable: 4996)
  #endif
  
  #include <UnigineEngine.h>
  #include <plugins/CUSTOMConnectorInterface.h>
  
  using namespace Unigine;
  
  extern "C" 
  {
  	//UNIGINE_EXPORT void CUSTOMConnector_method(CUSTOMConnector *self) { if (self) self->method(); }
  }
  
  //pop ignore deprecated warnings
  #ifdef __GNUC__
  #pragma GCC diagnostic pop
  #elif defined(_MSC_VER)
  #pragma warning(pop)
  #endif