Dynamically Loading Library as Plugin

#include <UnigineEngine.h>
#include <UniginePlugin.h>
#include <UnigineInterpreter.h>

/*
 */
using namespace Unigine;

/******************************************************************************\
*
* Step 1. MyFunction.
*
\******************************************************************************/

// 1. Create a custom print function that will be exported and accessible from the script.
void my_print(const char *str) {
	Log::warning("my_print(\"%s\"): called\n",str);
}

/******************************************************************************\
*
* Step 2. MyExternClass.
*
\******************************************************************************/

// 2. Create a custom class that will be exported and accessible from the script.
class MyExternClass {
		
	public:
		
		// 2.1. Declare a class constructor that will be exported into the script.	
		MyExternClass() { }
		~MyExternClass() { }
		
		// 2.2. Create a member that will also be exported into the script.
		void print(const char *str) {
			Log::warning("MyExternClass::print(\"%s\"): called\n",str);
		}
};

/******************************************************************************\
*
* Step 3. MyPlugin interface.
*
\******************************************************************************/

// 3.1. Create a plugin class - an implementation of the interface which provides access to this
// dynamic-link library by the Unigine executable.
class MyPlugin : public Plugin {
	
	public:
	
		// Declare a constructor and a destructor for the plugin.
		MyPlugin() {
			Log::warning("MyPlugin::MyPlugin(): called\n");
		}
		virtual ~MyPlugin() {
			Log::warning("MyPlugin::~MyPlugin(): called\n");
		}
		
		// plugin data
		virtual void *get_data() {
			return this;
		}
		
		// initialize plugin
		virtual int init();
		
		// shutdown plugin
		virtual int shutdown();
		
		// destroy plugin
		virtual void destroy();
		
		// initialize world
		virtual int initWorld();
		
		// shutdown world
		virtual int shutdownWorld();
};

// 3.2. Define plugin initialization function. The engine will automatically call it on its start-up.
int MyPlugin::init() {
	
	Log::warning("MyPlugin::init(): called\n");
	
	// 3.3. Export the custom function into the script.    
    // Create a pointer to the function and register its name to be used from the script
	Interpreter::addExternFunction("my_print",MakeExternFunction(&my_print));
	
	// 3.4. Export the custom class into the script.    
    // Create a pointer to the object of the external class 
	ExternClass<MyExternClass> *my_class = MakeExternClass<MyExternClass>();
	// Register a class constructor. If it was not declared explicitly, a default one will be
    // registered.
	my_class->addConstructor();
	// Register a class member function.
	my_class->addFunction("print",&MyExternClass::print);
	// Register the class.
	Interpreter::addExternClass("MyExternClass",my_class);
	
	return 1;
}

// 3.5. Define the plugin shutdown function. The engine will automatically call it on its shut down.
int MyPlugin::shutdown() {
	
	Log::warning("MyPlugin::shutdown(): called\n");
	
	// remove the function
	Interpreter::removeExternFunction("my_print");
	
	// remove the external class
	Interpreter::removeExternClass("MyExternClass");
	
	return 1;
}

/*
 */
// 3.6. Define the function which is called on the video mode restart
void MyPlugin::destroy() {
	
	Log::warning("MyPlugin::destroy(): called\n");
}

/*
 */
// 3.7. Define the function which is called on the world initialization
int MyPlugin::initWorld() {
	
	Log::error("\nMyPlugin::initWorld(): called\n\n");
	
	return 1;
}
// 3.8. Define the function which is called on the world shut down
int MyPlugin::shutdownWorld() {
	
	Log::error("\nMyPlugin::shutdownWorld(): called\n\n");
	
	return 1;
}

/******************************************************************************\
*
* Step 4. Plugin export.
*
\******************************************************************************/

// 4. Expose the created implementation of the plugin interface.
// 4.1. The engine will search for this function to add the plugin library.
// It returns a new instance of the custom plugin.
extern "C" UNIGINE_API void *CreatePlugin() {
	return new MyPlugin();
}

// 4.2. The engine will search for this function to release the plugin library.
// For that, a void pointer should be casted to the custom plugin type and then
// deleted.
extern "C" UNIGINE_API void ReleasePlugin(void *plugin) {
	delete static_cast<MyPlugin*>(plugin);
}

int init() {
	
	log.message("\n");
	
	// Call the function exported from the library:
	my_print("Hello world");
	
	log.message("\n");
	
	// Create new instances of the class exported from the library:
	MyExternClass my_class = new MyExternClass();
	
	// Call the exported members of the class:
	my_class.print("Hello world");
	
	delete my_class;
	
	// show the console
	engine.console.setActivity(1);
		
	return 1;
}

MyPlugin::MyPlugin(): called
MyPlugin::init(): called
my_print("Hello world"): called
MyExternClass::print("Hello world"): called
MyPlugin::update(): called

0: plugin/plugin 03FF0A00

Unigine~# video_restart

Set 1024x576 windowed mode
MyPlugin::destroy(): called
Set 1.00 gamma value

Unigine~# quit 

MyPlugin::shutdownWorld(): called

MyPlugin::shutdown(): called
MyPlugin::~MyPlugin(): called