Unigine::Landscape Class

// implement the SaveFile event handler
void savefile_event_handler(const UGUID & guid,  int operation_id,  const char * path_new_state,  const char * path_old_state)
{
	Log::message("\Handling SaveFile event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections savefile_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
Landscape::getEventSaveFile().connect(savefile_event_connections, savefile_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
Landscape::getEventSaveFile().connect(savefile_event_connections, [](const UGUID & guid,  int operation_id,  const char * path_new_state,  const char * path_old_state) { 
		Log::message("\Handling SaveFile event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
savefile_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection savefile_event_connection;

// subscribe to the SaveFile event with a handler function keeping the connection
Landscape::getEventSaveFile().connect(savefile_event_connection, savefile_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
savefile_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
savefile_event_connection.setEnabled(true);

// ...

// remove subscription to the SaveFile event via the connection
savefile_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A SaveFile event handler implemented as a class member
	void event_handler(const UGUID & guid,  int operation_id,  const char * path_new_state,  const char * path_old_state)
	{
		Log::message("\Handling SaveFile event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
Landscape::getEventSaveFile().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the SaveFile event with a handler function
Landscape::getEventSaveFile().connect(savefile_event_handler);


// remove subscription to the SaveFile event later by the handler function
Landscape::getEventSaveFile().disconnect(savefile_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId savefile_handler_id;

// subscribe to the SaveFile event with a lambda handler function and keeping connection ID
savefile_handler_id = Landscape::getEventSaveFile().connect([](const UGUID & guid,  int operation_id,  const char * path_new_state,  const char * path_old_state) { 
		Log::message("\Handling SaveFile event (lambda).\n");
	}
);

// remove the subscription later using the ID
Landscape::getEventSaveFile().disconnect(savefile_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all SaveFile events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
Landscape::getEventSaveFile().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
Landscape::getEventSaveFile().setEnabled(true);

// implement the ApplyDiff event handler
void applydiff_event_handler(const UGUID & guid,  int operation_id,  const char * lmap_file_path)
{
	Log::message("\Handling ApplyDiff event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections applydiff_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
Landscape::getEventApplyDiff().connect(applydiff_event_connections, applydiff_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
Landscape::getEventApplyDiff().connect(applydiff_event_connections, [](const UGUID & guid,  int operation_id,  const char * lmap_file_path) { 
		Log::message("\Handling ApplyDiff event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
applydiff_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection applydiff_event_connection;

// subscribe to the ApplyDiff event with a handler function keeping the connection
Landscape::getEventApplyDiff().connect(applydiff_event_connection, applydiff_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
applydiff_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
applydiff_event_connection.setEnabled(true);

// ...

// remove subscription to the ApplyDiff event via the connection
applydiff_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A ApplyDiff event handler implemented as a class member
	void event_handler(const UGUID & guid,  int operation_id,  const char * lmap_file_path)
	{
		Log::message("\Handling ApplyDiff event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
Landscape::getEventApplyDiff().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the ApplyDiff event with a handler function
Landscape::getEventApplyDiff().connect(applydiff_event_handler);


// remove subscription to the ApplyDiff event later by the handler function
Landscape::getEventApplyDiff().disconnect(applydiff_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId applydiff_handler_id;

// subscribe to the ApplyDiff event with a lambda handler function and keeping connection ID
applydiff_handler_id = Landscape::getEventApplyDiff().connect([](const UGUID & guid,  int operation_id,  const char * lmap_file_path) { 
		Log::message("\Handling ApplyDiff event (lambda).\n");
	}
);

// remove the subscription later using the ID
Landscape::getEventApplyDiff().disconnect(applydiff_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all ApplyDiff events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
Landscape::getEventApplyDiff().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
Landscape::getEventApplyDiff().setEnabled(true);

// implement the TextureDraw event handler
void texturedraw_event_handler(const UGUID & guid,  int operation_id,  const Ptr<LandscapeTextures> & buffer,  const Math::ivec2 & coords,  int data_mask)
{
	Log::message("\Handling TextureDraw event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections texturedraw_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
Landscape::getEventTextureDraw().connect(texturedraw_event_connections, texturedraw_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
Landscape::getEventTextureDraw().connect(texturedraw_event_connections, [](const UGUID & guid,  int operation_id,  const Ptr<LandscapeTextures> & buffer,  const Math::ivec2 & coords,  int data_mask) { 
		Log::message("\Handling TextureDraw event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
texturedraw_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection texturedraw_event_connection;

// subscribe to the TextureDraw event with a handler function keeping the connection
Landscape::getEventTextureDraw().connect(texturedraw_event_connection, texturedraw_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
texturedraw_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
texturedraw_event_connection.setEnabled(true);

// ...

// remove subscription to the TextureDraw event via the connection
texturedraw_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A TextureDraw event handler implemented as a class member
	void event_handler(const UGUID & guid,  int operation_id,  const Ptr<LandscapeTextures> & buffer,  const Math::ivec2 & coords,  int data_mask)
	{
		Log::message("\Handling TextureDraw event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
Landscape::getEventTextureDraw().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the TextureDraw event with a handler function
Landscape::getEventTextureDraw().connect(texturedraw_event_handler);


// remove subscription to the TextureDraw event later by the handler function
Landscape::getEventTextureDraw().disconnect(texturedraw_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId texturedraw_handler_id;

// subscribe to the TextureDraw event with a lambda handler function and keeping connection ID
texturedraw_handler_id = Landscape::getEventTextureDraw().connect([](const UGUID & guid,  int operation_id,  const Ptr<LandscapeTextures> & buffer,  const Math::ivec2 & coords,  int data_mask) { 
		Log::message("\Handling TextureDraw event (lambda).\n");
	}
);

// remove the subscription later using the ID
Landscape::getEventTextureDraw().disconnect(texturedraw_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all TextureDraw events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
Landscape::getEventTextureDraw().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
Landscape::getEventTextureDraw().setEnabled(true);