This page has been translated automatically.
Video Tutorials
Interface
Essentials
Advanced
How To
Rendering
Professional (SIM)
UnigineEditor
Interface Overview
Assets Workflow
Version Control
Settings and Preferences
Working With Projects
Adjusting Node Parameters
Setting Up Materials
Setting Up Properties
Lighting
Sandworm
Using Editor Tools for Specific Tasks
Extending Editor Functionality
Built-in Node Types
Nodes
Objects
Effects
Decals
Light Sources
Geodetics
World Nodes
Sound Objects
Pathfinding Objects
Players
Programming
Fundamentals
Setting Up Development Environment
Usage Examples
C++
C#
UnigineScript
UUSL (Unified UNIGINE Shader Language)
Plugins
File Formats
Materials and Shaders
Rebuilding the Engine Tools
GUI
VR Development
Double Precision Coordinates
API
Animations-Related Classes
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
VR-Related Classes
Content Creation
Content Optimization
Materials
Material Nodes Library
Miscellaneous
Input
Math
Matrix
Textures
Art Samples
Tutorials

Unigine::Viewport Class

Header: #include <UnigineViewport.h>

The Viewport class is used to render a scene with the specified settings.

The main use cases of the Viewport class are as follows:

  1. Integrate the engine to a 3rd party renderer (or vice versa) and render the image anywhere (via the render() method): to the external library, CustomSystemProxy interface, RenderTarget interface (a frame buffers abstraction), etc.

    • To render the image to the RenderTarget interface, do the following:

      Source code (C++)
      // mono rendering
      
      ViewportPtr viewport;
      TexturePtr texture;
      CameraPtr camera;
      
      int AppWorldLogic::init()
      {
      
      	viewport = Viewport::create();
      
      	texture = Texture::create();
      	// create 512 x 512 render target
      	texture->create2D(512, 512, Texture::FORMAT_RGBA8, Texture::FORMAT_USAGE_RENDER);
      	camera = Camera::create();
      	
      
      	return 1;
      }
      
      int AppWorldLogic::update()
      {
      
      	// set modelview & projection matrices to camera instance
      	// ...
      
      	// rendering
      	RenderTargetPtr render_target = Render::getTemporaryRenderTarget();
      	render_target->bindColorTexture(0, texture);
      	render_target->enable();
      	{
      		viewport->render(camera);
      	}
      	render_target->disable();
      	render_target->unbindAll();
      	Render::releaseTemporaryRenderTarget(render_target);
      
      	return 1;
      }

      To render the image to the RenderTarget interface in the stereo mode, do the following:

      Source code (C++)
      // stereo rendering
      
      ViewportPtr viewport;
      TexturePtr left_texture;
      TexturePtr right_texture;
      CameraPtr left_eye;
      CameraPtr right_eye;
      
      int AppWorldLogic::init()
      {
      	viewport = Viewport::create();
      
      	left_texture = Texture::create();
      	right_texture = Texture::create();
      
      	// create two 512 x 512 render target for each eye
      	left_texture->create2D(512, 512, Texture::FORMAT_RGBA8, Texture::FORMAT_USAGE_RENDER);
      	right_texture->create2D(512, 512, Texture::FORMAT_RGBA8, Texture::FORMAT_USAGE_RENDER);
      
      	left_eye = Camera::create();
      	right_eye = Camera::create();
      
      	return 1;
      }
      int AppWorldLogic::update()
      {
      	// set modelview & projection matrices to camera instance
      	// ...
      
      	// rendering
      	RenderTargetPtr render_target = Render::getTemporaryRenderTarget();
      	render_target->bindColorTexture(0, left_texture);
      	render_target->bindColorTexture(1, right_texture);
      	render_target->enable();
      	{
      		// use "post_stereo_separate" material in order to render to both textures
      		viewport->renderStereo(left_eye, right_eye, "Unigine::post_stereo_separate");
      	}
      	render_target->disable();
      	render_target->unbindAll();
      	Render::releaseTemporaryRenderTarget(render_target);
      
      	return 1;
      }
    • To render the image to the CustomSystemProxy interface, check the 3rd Party samples: source -> samples -> 3rdparty -> ViewportQt.

      Notice
      ViewportQt sample is available only for the Engineering and Sim editions of UNIGINE SDKs.
  2. Render a scene to a texture (data stays in the GPU memory).

  3. Render a node to a texture (data stays in the GPU memory).

You can subscribe to events before and after any rendering pass using the getEvent***(): thus, getting access to the intermediate state of rendering buffers and matrices. Some of them are read-only, but most of them can be modified ad hoc. The event handler can get a Renderer pointer.

Thanks to this feature you can get direct access to G-Buffer, SSAO, lights or any other effect. One more example: you can create a custom post-process and apply it before TAA, thus, getting correct antialiased image as a result. You can even create your own custom light sources, decals, etc. The feature can also be useful for custom sensors view.

Viewport class has different rendering modes: RENDER_DEPTH (depth only), RENDER_DEPTH_GBUFFER (depth + G-buffer), RENDER_DEPTH_GBUFFER_FINAL (depth + G-buffer + final image). This can give you extra performance boost if you need only depth info, for example.

Notice

To set any viewport as a main, use the setViewport() method of the Render class.

A single viewport should be used with a single camera, otherwise it may cause visual artefacts. To avoid artefacts, when using several cameras with a single viewport, all post effects must be disabled using the setSkipFlags() method with the SKIP_POSTEFFECTS flag. See the usage example below.

See also#

Viewport Class

Members

isStereo() const#

Returns the current value indicating if the stereo rendering is enabled for the current viewport (one of the stereo modes is set).

Return value

Current

isPanorama() const#

Returns the current value indicating if the panoramic rendering is enabled.

Return value

Current

getID() const#

Returns the current viewport id.

Return value

Current

void setLifetime ( int lifetime ) #

Sets a new value indicating how many frames temporary viewport resources are available after the viewport stops rendering.

Arguments

  • int lifetime - The number of frames during which temporary viewport resources are available after the viewport stops rendering

int getLifetime() const#

Returns the current value indicating how many frames temporary viewport resources are available after the viewport stops rendering.

Return value

Current number of frames during which temporary viewport resources are available after the viewport stops rendering

Event<> getEventEnd() const#

event triggered when rendering of the frame ends. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the End event handler
void end_event_handler()
{
	Log::message("\Handling End 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 end_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEnd().connect(end_event_connections, end_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEnd().connect(end_event_connections, []() { 
		Log::message("\Handling End event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
end_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 end_event_connection;

// subscribe to the End event with a handler function keeping the connection
publisher->getEventEnd().connect(end_event_connection, end_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the End event via the connection
end_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 End event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling End event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEnd().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 End event with a handler function
publisher->getEventEnd().connect(end_event_handler);


// remove subscription to the End event later by the handler function
publisher->getEventEnd().disconnect(end_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 end_handler_id;

// subscribe to the End event with a lambda handler function and keeping connection ID
end_handler_id = publisher->getEventEnd().connect([]() { 
		Log::message("\Handling End event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEnd().disconnect(end_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEnd().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEnd().setEnabled(true);

Return value

Event reference.

Event<> getEventEndScreen() const#

event triggered after the stage of rendering each screen (a stereo image has 2 screens, while a cubemap will have 6). You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndScreen event handler
void endscreen_event_handler()
{
	Log::message("\Handling EndScreen 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 endscreen_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndScreen().connect(endscreen_event_connections, endscreen_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndScreen().connect(endscreen_event_connections, []() { 
		Log::message("\Handling EndScreen event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endscreen_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 endscreen_event_connection;

// subscribe to the EndScreen event with a handler function keeping the connection
publisher->getEventEndScreen().connect(endscreen_event_connection, endscreen_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndScreen event via the connection
endscreen_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 EndScreen event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndScreen event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndScreen().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 EndScreen event with a handler function
publisher->getEventEndScreen().connect(endscreen_event_handler);


// remove subscription to the EndScreen event later by the handler function
publisher->getEventEndScreen().disconnect(endscreen_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 endscreen_handler_id;

// subscribe to the EndScreen event with a lambda handler function and keeping connection ID
endscreen_handler_id = publisher->getEventEndScreen().connect([]() { 
		Log::message("\Handling EndScreen event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndScreen().disconnect(endscreen_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndScreen().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndScreen().setEnabled(true);

Return value

Event reference.

Event<> getEventEndVisualizer() const#

event triggered after the visualizer rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndVisualizer event handler
void endvisualizer_event_handler()
{
	Log::message("\Handling EndVisualizer 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 endvisualizer_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndVisualizer().connect(endvisualizer_event_connections, endvisualizer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndVisualizer().connect(endvisualizer_event_connections, []() { 
		Log::message("\Handling EndVisualizer event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endvisualizer_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 endvisualizer_event_connection;

// subscribe to the EndVisualizer event with a handler function keeping the connection
publisher->getEventEndVisualizer().connect(endvisualizer_event_connection, endvisualizer_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndVisualizer event via the connection
endvisualizer_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 EndVisualizer event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndVisualizer event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndVisualizer().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 EndVisualizer event with a handler function
publisher->getEventEndVisualizer().connect(endvisualizer_event_handler);


// remove subscription to the EndVisualizer event later by the handler function
publisher->getEventEndVisualizer().disconnect(endvisualizer_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 endvisualizer_handler_id;

// subscribe to the EndVisualizer event with a lambda handler function and keeping connection ID
endvisualizer_handler_id = publisher->getEventEndVisualizer().connect([]() { 
		Log::message("\Handling EndVisualizer event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndVisualizer().disconnect(endvisualizer_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndVisualizer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndVisualizer().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginVisualizer() const#

event triggered before the visualizer rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginVisualizer event handler
void beginvisualizer_event_handler()
{
	Log::message("\Handling BeginVisualizer 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 beginvisualizer_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginVisualizer().connect(beginvisualizer_event_connections, beginvisualizer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginVisualizer().connect(beginvisualizer_event_connections, []() { 
		Log::message("\Handling BeginVisualizer event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginvisualizer_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 beginvisualizer_event_connection;

// subscribe to the BeginVisualizer event with a handler function keeping the connection
publisher->getEventBeginVisualizer().connect(beginvisualizer_event_connection, beginvisualizer_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginVisualizer event via the connection
beginvisualizer_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 BeginVisualizer event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginVisualizer event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginVisualizer().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 BeginVisualizer event with a handler function
publisher->getEventBeginVisualizer().connect(beginvisualizer_event_handler);


// remove subscription to the BeginVisualizer event later by the handler function
publisher->getEventBeginVisualizer().disconnect(beginvisualizer_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 beginvisualizer_handler_id;

// subscribe to the BeginVisualizer event with a lambda handler function and keeping connection ID
beginvisualizer_handler_id = publisher->getEventBeginVisualizer().connect([]() { 
		Log::message("\Handling BeginVisualizer event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginVisualizer().disconnect(beginvisualizer_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginVisualizer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginVisualizer().setEnabled(true);

Return value

Event reference.

Event<> getEventEndDebugMaterials() const#

event triggered after the debug materials stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndDebugMaterials event handler
void enddebugmaterials_event_handler()
{
	Log::message("\Handling EndDebugMaterials 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 enddebugmaterials_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndDebugMaterials().connect(enddebugmaterials_event_connections, enddebugmaterials_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndDebugMaterials().connect(enddebugmaterials_event_connections, []() { 
		Log::message("\Handling EndDebugMaterials event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
enddebugmaterials_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 enddebugmaterials_event_connection;

// subscribe to the EndDebugMaterials event with a handler function keeping the connection
publisher->getEventEndDebugMaterials().connect(enddebugmaterials_event_connection, enddebugmaterials_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndDebugMaterials event via the connection
enddebugmaterials_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 EndDebugMaterials event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndDebugMaterials event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndDebugMaterials().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 EndDebugMaterials event with a handler function
publisher->getEventEndDebugMaterials().connect(enddebugmaterials_event_handler);


// remove subscription to the EndDebugMaterials event later by the handler function
publisher->getEventEndDebugMaterials().disconnect(enddebugmaterials_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 enddebugmaterials_handler_id;

// subscribe to the EndDebugMaterials event with a lambda handler function and keeping connection ID
enddebugmaterials_handler_id = publisher->getEventEndDebugMaterials().connect([]() { 
		Log::message("\Handling EndDebugMaterials event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndDebugMaterials().disconnect(enddebugmaterials_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndDebugMaterials().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndDebugMaterials().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginDebugMaterials() const#

event triggered before the debug materials stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginDebugMaterials event handler
void begindebugmaterials_event_handler()
{
	Log::message("\Handling BeginDebugMaterials 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 begindebugmaterials_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginDebugMaterials().connect(begindebugmaterials_event_connections, begindebugmaterials_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginDebugMaterials().connect(begindebugmaterials_event_connections, []() { 
		Log::message("\Handling BeginDebugMaterials event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
begindebugmaterials_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 begindebugmaterials_event_connection;

// subscribe to the BeginDebugMaterials event with a handler function keeping the connection
publisher->getEventBeginDebugMaterials().connect(begindebugmaterials_event_connection, begindebugmaterials_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginDebugMaterials event via the connection
begindebugmaterials_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 BeginDebugMaterials event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginDebugMaterials event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginDebugMaterials().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 BeginDebugMaterials event with a handler function
publisher->getEventBeginDebugMaterials().connect(begindebugmaterials_event_handler);


// remove subscription to the BeginDebugMaterials event later by the handler function
publisher->getEventBeginDebugMaterials().disconnect(begindebugmaterials_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 begindebugmaterials_handler_id;

// subscribe to the BeginDebugMaterials event with a lambda handler function and keeping connection ID
begindebugmaterials_handler_id = publisher->getEventBeginDebugMaterials().connect([]() { 
		Log::message("\Handling BeginDebugMaterials event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginDebugMaterials().disconnect(begindebugmaterials_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginDebugMaterials().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginDebugMaterials().setEnabled(true);

Return value

Event reference.

Event<> getEventEndPostMaterials() const#

event triggered after the post materials rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndPostMaterials event handler
void endpostmaterials_event_handler()
{
	Log::message("\Handling EndPostMaterials 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 endpostmaterials_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndPostMaterials().connect(endpostmaterials_event_connections, endpostmaterials_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndPostMaterials().connect(endpostmaterials_event_connections, []() { 
		Log::message("\Handling EndPostMaterials event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endpostmaterials_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 endpostmaterials_event_connection;

// subscribe to the EndPostMaterials event with a handler function keeping the connection
publisher->getEventEndPostMaterials().connect(endpostmaterials_event_connection, endpostmaterials_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndPostMaterials event via the connection
endpostmaterials_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 EndPostMaterials event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndPostMaterials event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndPostMaterials().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 EndPostMaterials event with a handler function
publisher->getEventEndPostMaterials().connect(endpostmaterials_event_handler);


// remove subscription to the EndPostMaterials event later by the handler function
publisher->getEventEndPostMaterials().disconnect(endpostmaterials_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 endpostmaterials_handler_id;

// subscribe to the EndPostMaterials event with a lambda handler function and keeping connection ID
endpostmaterials_handler_id = publisher->getEventEndPostMaterials().connect([]() { 
		Log::message("\Handling EndPostMaterials event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndPostMaterials().disconnect(endpostmaterials_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndPostMaterials().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndPostMaterials().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginPostMaterials() const#

event triggered before the post materials rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginPostMaterials event handler
void beginpostmaterials_event_handler()
{
	Log::message("\Handling BeginPostMaterials 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 beginpostmaterials_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginPostMaterials().connect(beginpostmaterials_event_connections, beginpostmaterials_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginPostMaterials().connect(beginpostmaterials_event_connections, []() { 
		Log::message("\Handling BeginPostMaterials event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginpostmaterials_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 beginpostmaterials_event_connection;

// subscribe to the BeginPostMaterials event with a handler function keeping the connection
publisher->getEventBeginPostMaterials().connect(beginpostmaterials_event_connection, beginpostmaterials_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginPostMaterials event via the connection
beginpostmaterials_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 BeginPostMaterials event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginPostMaterials event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginPostMaterials().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 BeginPostMaterials event with a handler function
publisher->getEventBeginPostMaterials().connect(beginpostmaterials_event_handler);


// remove subscription to the BeginPostMaterials event later by the handler function
publisher->getEventBeginPostMaterials().disconnect(beginpostmaterials_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 beginpostmaterials_handler_id;

// subscribe to the BeginPostMaterials event with a lambda handler function and keeping connection ID
beginpostmaterials_handler_id = publisher->getEventBeginPostMaterials().connect([]() { 
		Log::message("\Handling BeginPostMaterials event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginPostMaterials().disconnect(beginpostmaterials_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginPostMaterials().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginPostMaterials().setEnabled(true);

Return value

Event reference.

Event<> getEventEndCameraEffects() const#

event triggered after the camera effects stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndCameraEffects event handler
void endcameraeffects_event_handler()
{
	Log::message("\Handling EndCameraEffects 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 endcameraeffects_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndCameraEffects().connect(endcameraeffects_event_connections, endcameraeffects_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndCameraEffects().connect(endcameraeffects_event_connections, []() { 
		Log::message("\Handling EndCameraEffects event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endcameraeffects_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 endcameraeffects_event_connection;

// subscribe to the EndCameraEffects event with a handler function keeping the connection
publisher->getEventEndCameraEffects().connect(endcameraeffects_event_connection, endcameraeffects_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndCameraEffects event via the connection
endcameraeffects_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 EndCameraEffects event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndCameraEffects event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndCameraEffects().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 EndCameraEffects event with a handler function
publisher->getEventEndCameraEffects().connect(endcameraeffects_event_handler);


// remove subscription to the EndCameraEffects event later by the handler function
publisher->getEventEndCameraEffects().disconnect(endcameraeffects_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 endcameraeffects_handler_id;

// subscribe to the EndCameraEffects event with a lambda handler function and keeping connection ID
endcameraeffects_handler_id = publisher->getEventEndCameraEffects().connect([]() { 
		Log::message("\Handling EndCameraEffects event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndCameraEffects().disconnect(endcameraeffects_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndCameraEffects().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndCameraEffects().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginCameraEffects() const#

event triggered before the camera effects stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginCameraEffects event handler
void begincameraeffects_event_handler()
{
	Log::message("\Handling BeginCameraEffects 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 begincameraeffects_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginCameraEffects().connect(begincameraeffects_event_connections, begincameraeffects_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginCameraEffects().connect(begincameraeffects_event_connections, []() { 
		Log::message("\Handling BeginCameraEffects event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
begincameraeffects_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 begincameraeffects_event_connection;

// subscribe to the BeginCameraEffects event with a handler function keeping the connection
publisher->getEventBeginCameraEffects().connect(begincameraeffects_event_connection, begincameraeffects_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginCameraEffects event via the connection
begincameraeffects_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 BeginCameraEffects event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginCameraEffects event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginCameraEffects().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 BeginCameraEffects event with a handler function
publisher->getEventBeginCameraEffects().connect(begincameraeffects_event_handler);


// remove subscription to the BeginCameraEffects event later by the handler function
publisher->getEventBeginCameraEffects().disconnect(begincameraeffects_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 begincameraeffects_handler_id;

// subscribe to the BeginCameraEffects event with a lambda handler function and keeping connection ID
begincameraeffects_handler_id = publisher->getEventBeginCameraEffects().connect([]() { 
		Log::message("\Handling BeginCameraEffects event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginCameraEffects().disconnect(begincameraeffects_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginCameraEffects().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginCameraEffects().setEnabled(true);

Return value

Event reference.

Event<> getEventEndTAA() const#

event triggered after the Temporal Anti-Aliasing (TAA) pass. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndTAA event handler
void endtaa_event_handler()
{
	Log::message("\Handling EndTAA 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 endtaa_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndTAA().connect(endtaa_event_connections, endtaa_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndTAA().connect(endtaa_event_connections, []() { 
		Log::message("\Handling EndTAA event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endtaa_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 endtaa_event_connection;

// subscribe to the EndTAA event with a handler function keeping the connection
publisher->getEventEndTAA().connect(endtaa_event_connection, endtaa_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndTAA event via the connection
endtaa_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 EndTAA event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndTAA event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndTAA().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 EndTAA event with a handler function
publisher->getEventEndTAA().connect(endtaa_event_handler);


// remove subscription to the EndTAA event later by the handler function
publisher->getEventEndTAA().disconnect(endtaa_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 endtaa_handler_id;

// subscribe to the EndTAA event with a lambda handler function and keeping connection ID
endtaa_handler_id = publisher->getEventEndTAA().connect([]() { 
		Log::message("\Handling EndTAA event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndTAA().disconnect(endtaa_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndTAA().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndTAA().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginTAA() const#

event triggered before the Temporal Anti-Aliasing (TAA) pass. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginTAA event handler
void begintaa_event_handler()
{
	Log::message("\Handling BeginTAA 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 begintaa_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginTAA().connect(begintaa_event_connections, begintaa_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginTAA().connect(begintaa_event_connections, []() { 
		Log::message("\Handling BeginTAA event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
begintaa_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 begintaa_event_connection;

// subscribe to the BeginTAA event with a handler function keeping the connection
publisher->getEventBeginTAA().connect(begintaa_event_connection, begintaa_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginTAA event via the connection
begintaa_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 BeginTAA event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginTAA event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginTAA().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 BeginTAA event with a handler function
publisher->getEventBeginTAA().connect(begintaa_event_handler);


// remove subscription to the BeginTAA event later by the handler function
publisher->getEventBeginTAA().disconnect(begintaa_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 begintaa_handler_id;

// subscribe to the BeginTAA event with a lambda handler function and keeping connection ID
begintaa_handler_id = publisher->getEventBeginTAA().connect([]() { 
		Log::message("\Handling BeginTAA event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginTAA().disconnect(begintaa_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginTAA().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginTAA().setEnabled(true);

Return value

Event reference.

Event<> getEventEndAdaptationColor() const#

event triggered after the color adaptation rendering stage (automatic exposure and white balance correction). You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndAdaptationColor event handler
void endadaptationcolor_event_handler()
{
	Log::message("\Handling EndAdaptationColor 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 endadaptationcolor_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndAdaptationColor().connect(endadaptationcolor_event_connections, endadaptationcolor_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndAdaptationColor().connect(endadaptationcolor_event_connections, []() { 
		Log::message("\Handling EndAdaptationColor event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endadaptationcolor_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 endadaptationcolor_event_connection;

// subscribe to the EndAdaptationColor event with a handler function keeping the connection
publisher->getEventEndAdaptationColor().connect(endadaptationcolor_event_connection, endadaptationcolor_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndAdaptationColor event via the connection
endadaptationcolor_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 EndAdaptationColor event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndAdaptationColor event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndAdaptationColor().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 EndAdaptationColor event with a handler function
publisher->getEventEndAdaptationColor().connect(endadaptationcolor_event_handler);


// remove subscription to the EndAdaptationColor event later by the handler function
publisher->getEventEndAdaptationColor().disconnect(endadaptationcolor_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 endadaptationcolor_handler_id;

// subscribe to the EndAdaptationColor event with a lambda handler function and keeping connection ID
endadaptationcolor_handler_id = publisher->getEventEndAdaptationColor().connect([]() { 
		Log::message("\Handling EndAdaptationColor event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndAdaptationColor().disconnect(endadaptationcolor_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndAdaptationColor().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndAdaptationColor().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginAdaptationColor() const#

event triggered before the color adaptation rendering stage (automatic exposure and white balance correction). You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginAdaptationColor event handler
void beginadaptationcolor_event_handler()
{
	Log::message("\Handling BeginAdaptationColor 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 beginadaptationcolor_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginAdaptationColor().connect(beginadaptationcolor_event_connections, beginadaptationcolor_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginAdaptationColor().connect(beginadaptationcolor_event_connections, []() { 
		Log::message("\Handling BeginAdaptationColor event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginadaptationcolor_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 beginadaptationcolor_event_connection;

// subscribe to the BeginAdaptationColor event with a handler function keeping the connection
publisher->getEventBeginAdaptationColor().connect(beginadaptationcolor_event_connection, beginadaptationcolor_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginAdaptationColor event via the connection
beginadaptationcolor_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 BeginAdaptationColor event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginAdaptationColor event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginAdaptationColor().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 BeginAdaptationColor event with a handler function
publisher->getEventBeginAdaptationColor().connect(beginadaptationcolor_event_handler);


// remove subscription to the BeginAdaptationColor event later by the handler function
publisher->getEventBeginAdaptationColor().disconnect(beginadaptationcolor_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 beginadaptationcolor_handler_id;

// subscribe to the BeginAdaptationColor event with a lambda handler function and keeping connection ID
beginadaptationcolor_handler_id = publisher->getEventBeginAdaptationColor().connect([]() { 
		Log::message("\Handling BeginAdaptationColor event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginAdaptationColor().disconnect(beginadaptationcolor_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginAdaptationColor().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginAdaptationColor().setEnabled(true);

Return value

Event reference.

Event<> getEventEndAdaptationColorAverage() const#

event triggered after the calculation of automatic exposure and white balance correction. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndAdaptationColorAverage event handler
void endadaptationcoloraverage_event_handler()
{
	Log::message("\Handling EndAdaptationColorAverage 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 endadaptationcoloraverage_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndAdaptationColorAverage().connect(endadaptationcoloraverage_event_connections, endadaptationcoloraverage_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndAdaptationColorAverage().connect(endadaptationcoloraverage_event_connections, []() { 
		Log::message("\Handling EndAdaptationColorAverage event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endadaptationcoloraverage_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 endadaptationcoloraverage_event_connection;

// subscribe to the EndAdaptationColorAverage event with a handler function keeping the connection
publisher->getEventEndAdaptationColorAverage().connect(endadaptationcoloraverage_event_connection, endadaptationcoloraverage_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndAdaptationColorAverage event via the connection
endadaptationcoloraverage_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 EndAdaptationColorAverage event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndAdaptationColorAverage event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndAdaptationColorAverage().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 EndAdaptationColorAverage event with a handler function
publisher->getEventEndAdaptationColorAverage().connect(endadaptationcoloraverage_event_handler);


// remove subscription to the EndAdaptationColorAverage event later by the handler function
publisher->getEventEndAdaptationColorAverage().disconnect(endadaptationcoloraverage_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 endadaptationcoloraverage_handler_id;

// subscribe to the EndAdaptationColorAverage event with a lambda handler function and keeping connection ID
endadaptationcoloraverage_handler_id = publisher->getEventEndAdaptationColorAverage().connect([]() { 
		Log::message("\Handling EndAdaptationColorAverage event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndAdaptationColorAverage().disconnect(endadaptationcoloraverage_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndAdaptationColorAverage().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndAdaptationColorAverage().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginAdaptationColorAverage() const#

event triggered before the calculation of automatic exposure and white balance correction. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginAdaptationColorAverage event handler
void beginadaptationcoloraverage_event_handler()
{
	Log::message("\Handling BeginAdaptationColorAverage 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 beginadaptationcoloraverage_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginAdaptationColorAverage().connect(beginadaptationcoloraverage_event_connections, beginadaptationcoloraverage_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginAdaptationColorAverage().connect(beginadaptationcoloraverage_event_connections, []() { 
		Log::message("\Handling BeginAdaptationColorAverage event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginadaptationcoloraverage_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 beginadaptationcoloraverage_event_connection;

// subscribe to the BeginAdaptationColorAverage event with a handler function keeping the connection
publisher->getEventBeginAdaptationColorAverage().connect(beginadaptationcoloraverage_event_connection, beginadaptationcoloraverage_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginAdaptationColorAverage event via the connection
beginadaptationcoloraverage_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 BeginAdaptationColorAverage event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginAdaptationColorAverage event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginAdaptationColorAverage().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 BeginAdaptationColorAverage event with a handler function
publisher->getEventBeginAdaptationColorAverage().connect(beginadaptationcoloraverage_event_handler);


// remove subscription to the BeginAdaptationColorAverage event later by the handler function
publisher->getEventBeginAdaptationColorAverage().disconnect(beginadaptationcoloraverage_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 beginadaptationcoloraverage_handler_id;

// subscribe to the BeginAdaptationColorAverage event with a lambda handler function and keeping connection ID
beginadaptationcoloraverage_handler_id = publisher->getEventBeginAdaptationColorAverage().connect([]() { 
		Log::message("\Handling BeginAdaptationColorAverage event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginAdaptationColorAverage().disconnect(beginadaptationcoloraverage_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginAdaptationColorAverage().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginAdaptationColorAverage().setEnabled(true);

Return value

Event reference.

Event<> getEventEndSrgbCorrection() const#

event triggered after the sRGB correction stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndSrgbCorrection event handler
void endsrgbcorrection_event_handler()
{
	Log::message("\Handling EndSrgbCorrection 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 endsrgbcorrection_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSrgbCorrection().connect(endsrgbcorrection_event_connections, endsrgbcorrection_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSrgbCorrection().connect(endsrgbcorrection_event_connections, []() { 
		Log::message("\Handling EndSrgbCorrection event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endsrgbcorrection_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 endsrgbcorrection_event_connection;

// subscribe to the EndSrgbCorrection event with a handler function keeping the connection
publisher->getEventEndSrgbCorrection().connect(endsrgbcorrection_event_connection, endsrgbcorrection_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndSrgbCorrection event via the connection
endsrgbcorrection_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 EndSrgbCorrection event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndSrgbCorrection event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSrgbCorrection().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 EndSrgbCorrection event with a handler function
publisher->getEventEndSrgbCorrection().connect(endsrgbcorrection_event_handler);


// remove subscription to the EndSrgbCorrection event later by the handler function
publisher->getEventEndSrgbCorrection().disconnect(endsrgbcorrection_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 endsrgbcorrection_handler_id;

// subscribe to the EndSrgbCorrection event with a lambda handler function and keeping connection ID
endsrgbcorrection_handler_id = publisher->getEventEndSrgbCorrection().connect([]() { 
		Log::message("\Handling EndSrgbCorrection event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndSrgbCorrection().disconnect(endsrgbcorrection_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSrgbCorrection().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndSrgbCorrection().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginSrgbCorrection() const#

event triggered before the sRGB correction stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginSrgbCorrection event handler
void beginsrgbcorrection_event_handler()
{
	Log::message("\Handling BeginSrgbCorrection 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 beginsrgbcorrection_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSrgbCorrection().connect(beginsrgbcorrection_event_connections, beginsrgbcorrection_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSrgbCorrection().connect(beginsrgbcorrection_event_connections, []() { 
		Log::message("\Handling BeginSrgbCorrection event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginsrgbcorrection_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 beginsrgbcorrection_event_connection;

// subscribe to the BeginSrgbCorrection event with a handler function keeping the connection
publisher->getEventBeginSrgbCorrection().connect(beginsrgbcorrection_event_connection, beginsrgbcorrection_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginSrgbCorrection event via the connection
beginsrgbcorrection_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 BeginSrgbCorrection event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginSrgbCorrection event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSrgbCorrection().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 BeginSrgbCorrection event with a handler function
publisher->getEventBeginSrgbCorrection().connect(beginsrgbcorrection_event_handler);


// remove subscription to the BeginSrgbCorrection event later by the handler function
publisher->getEventBeginSrgbCorrection().disconnect(beginsrgbcorrection_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 beginsrgbcorrection_handler_id;

// subscribe to the BeginSrgbCorrection event with a lambda handler function and keeping connection ID
beginsrgbcorrection_handler_id = publisher->getEventBeginSrgbCorrection().connect([]() { 
		Log::message("\Handling BeginSrgbCorrection event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginSrgbCorrection().disconnect(beginsrgbcorrection_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSrgbCorrection().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginSrgbCorrection().setEnabled(true);

Return value

Event reference.

Event<> getEventEndTransparent() const#

event triggered after the transparent objects rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndTransparent event handler
void endtransparent_event_handler()
{
	Log::message("\Handling EndTransparent 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 endtransparent_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndTransparent().connect(endtransparent_event_connections, endtransparent_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndTransparent().connect(endtransparent_event_connections, []() { 
		Log::message("\Handling EndTransparent event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endtransparent_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 endtransparent_event_connection;

// subscribe to the EndTransparent event with a handler function keeping the connection
publisher->getEventEndTransparent().connect(endtransparent_event_connection, endtransparent_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndTransparent event via the connection
endtransparent_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 EndTransparent event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndTransparent event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndTransparent().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 EndTransparent event with a handler function
publisher->getEventEndTransparent().connect(endtransparent_event_handler);


// remove subscription to the EndTransparent event later by the handler function
publisher->getEventEndTransparent().disconnect(endtransparent_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 endtransparent_handler_id;

// subscribe to the EndTransparent event with a lambda handler function and keeping connection ID
endtransparent_handler_id = publisher->getEventEndTransparent().connect([]() { 
		Log::message("\Handling EndTransparent event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndTransparent().disconnect(endtransparent_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndTransparent().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndTransparent().setEnabled(true);

Return value

Event reference.

Event<> getEventEndWater() const#

event triggered after the water rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndWater event handler
void endwater_event_handler()
{
	Log::message("\Handling EndWater 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 endwater_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWater().connect(endwater_event_connections, endwater_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWater().connect(endwater_event_connections, []() { 
		Log::message("\Handling EndWater event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endwater_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 endwater_event_connection;

// subscribe to the EndWater event with a handler function keeping the connection
publisher->getEventEndWater().connect(endwater_event_connection, endwater_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndWater event via the connection
endwater_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 EndWater event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndWater event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWater().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 EndWater event with a handler function
publisher->getEventEndWater().connect(endwater_event_handler);


// remove subscription to the EndWater event later by the handler function
publisher->getEventEndWater().disconnect(endwater_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 endwater_handler_id;

// subscribe to the EndWater event with a lambda handler function and keeping connection ID
endwater_handler_id = publisher->getEventEndWater().connect([]() { 
		Log::message("\Handling EndWater event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndWater().disconnect(endwater_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWater().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndWater().setEnabled(true);

Return value

Event reference.

Event<> getEventEndWaterPlanarProbes() const#

event triggered after the water planar probes rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndWaterPlanarProbes event handler
void endwaterplanarprobes_event_handler()
{
	Log::message("\Handling EndWaterPlanarProbes 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 endwaterplanarprobes_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWaterPlanarProbes().connect(endwaterplanarprobes_event_connections, endwaterplanarprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWaterPlanarProbes().connect(endwaterplanarprobes_event_connections, []() { 
		Log::message("\Handling EndWaterPlanarProbes event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endwaterplanarprobes_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 endwaterplanarprobes_event_connection;

// subscribe to the EndWaterPlanarProbes event with a handler function keeping the connection
publisher->getEventEndWaterPlanarProbes().connect(endwaterplanarprobes_event_connection, endwaterplanarprobes_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndWaterPlanarProbes event via the connection
endwaterplanarprobes_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 EndWaterPlanarProbes event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndWaterPlanarProbes event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWaterPlanarProbes().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 EndWaterPlanarProbes event with a handler function
publisher->getEventEndWaterPlanarProbes().connect(endwaterplanarprobes_event_handler);


// remove subscription to the EndWaterPlanarProbes event later by the handler function
publisher->getEventEndWaterPlanarProbes().disconnect(endwaterplanarprobes_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 endwaterplanarprobes_handler_id;

// subscribe to the EndWaterPlanarProbes event with a lambda handler function and keeping connection ID
endwaterplanarprobes_handler_id = publisher->getEventEndWaterPlanarProbes().connect([]() { 
		Log::message("\Handling EndWaterPlanarProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndWaterPlanarProbes().disconnect(endwaterplanarprobes_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWaterPlanarProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndWaterPlanarProbes().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginWaterPlanarProbes() const#

event triggered before the water planar probes rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginWaterPlanarProbes event handler
void beginwaterplanarprobes_event_handler()
{
	Log::message("\Handling BeginWaterPlanarProbes 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 beginwaterplanarprobes_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWaterPlanarProbes().connect(beginwaterplanarprobes_event_connections, beginwaterplanarprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWaterPlanarProbes().connect(beginwaterplanarprobes_event_connections, []() { 
		Log::message("\Handling BeginWaterPlanarProbes event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginwaterplanarprobes_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 beginwaterplanarprobes_event_connection;

// subscribe to the BeginWaterPlanarProbes event with a handler function keeping the connection
publisher->getEventBeginWaterPlanarProbes().connect(beginwaterplanarprobes_event_connection, beginwaterplanarprobes_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginWaterPlanarProbes event via the connection
beginwaterplanarprobes_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 BeginWaterPlanarProbes event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginWaterPlanarProbes event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWaterPlanarProbes().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 BeginWaterPlanarProbes event with a handler function
publisher->getEventBeginWaterPlanarProbes().connect(beginwaterplanarprobes_event_handler);


// remove subscription to the BeginWaterPlanarProbes event later by the handler function
publisher->getEventBeginWaterPlanarProbes().disconnect(beginwaterplanarprobes_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 beginwaterplanarprobes_handler_id;

// subscribe to the BeginWaterPlanarProbes event with a lambda handler function and keeping connection ID
beginwaterplanarprobes_handler_id = publisher->getEventBeginWaterPlanarProbes().connect([]() { 
		Log::message("\Handling BeginWaterPlanarProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginWaterPlanarProbes().disconnect(beginwaterplanarprobes_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWaterPlanarProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginWaterPlanarProbes().setEnabled(true);

Return value

Event reference.

Event<> getEventEndWaterEnvironmentProbes() const#

event triggered after the water environment probes rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndWaterEnvironmentProbes event handler
void endwaterenvironmentprobes_event_handler()
{
	Log::message("\Handling EndWaterEnvironmentProbes 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 endwaterenvironmentprobes_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWaterEnvironmentProbes().connect(endwaterenvironmentprobes_event_connections, endwaterenvironmentprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWaterEnvironmentProbes().connect(endwaterenvironmentprobes_event_connections, []() { 
		Log::message("\Handling EndWaterEnvironmentProbes event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endwaterenvironmentprobes_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 endwaterenvironmentprobes_event_connection;

// subscribe to the EndWaterEnvironmentProbes event with a handler function keeping the connection
publisher->getEventEndWaterEnvironmentProbes().connect(endwaterenvironmentprobes_event_connection, endwaterenvironmentprobes_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndWaterEnvironmentProbes event via the connection
endwaterenvironmentprobes_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 EndWaterEnvironmentProbes event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndWaterEnvironmentProbes event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWaterEnvironmentProbes().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 EndWaterEnvironmentProbes event with a handler function
publisher->getEventEndWaterEnvironmentProbes().connect(endwaterenvironmentprobes_event_handler);


// remove subscription to the EndWaterEnvironmentProbes event later by the handler function
publisher->getEventEndWaterEnvironmentProbes().disconnect(endwaterenvironmentprobes_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 endwaterenvironmentprobes_handler_id;

// subscribe to the EndWaterEnvironmentProbes event with a lambda handler function and keeping connection ID
endwaterenvironmentprobes_handler_id = publisher->getEventEndWaterEnvironmentProbes().connect([]() { 
		Log::message("\Handling EndWaterEnvironmentProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndWaterEnvironmentProbes().disconnect(endwaterenvironmentprobes_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWaterEnvironmentProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndWaterEnvironmentProbes().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginWaterEnvironmentProbes() const#

event triggered before the water environment probes rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginWaterEnvironmentProbes event handler
void beginwaterenvironmentprobes_event_handler()
{
	Log::message("\Handling BeginWaterEnvironmentProbes 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 beginwaterenvironmentprobes_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWaterEnvironmentProbes().connect(beginwaterenvironmentprobes_event_connections, beginwaterenvironmentprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWaterEnvironmentProbes().connect(beginwaterenvironmentprobes_event_connections, []() { 
		Log::message("\Handling BeginWaterEnvironmentProbes event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginwaterenvironmentprobes_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 beginwaterenvironmentprobes_event_connection;

// subscribe to the BeginWaterEnvironmentProbes event with a handler function keeping the connection
publisher->getEventBeginWaterEnvironmentProbes().connect(beginwaterenvironmentprobes_event_connection, beginwaterenvironmentprobes_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginWaterEnvironmentProbes event via the connection
beginwaterenvironmentprobes_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 BeginWaterEnvironmentProbes event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginWaterEnvironmentProbes event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWaterEnvironmentProbes().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 BeginWaterEnvironmentProbes event with a handler function
publisher->getEventBeginWaterEnvironmentProbes().connect(beginwaterenvironmentprobes_event_handler);


// remove subscription to the BeginWaterEnvironmentProbes event later by the handler function
publisher->getEventBeginWaterEnvironmentProbes().disconnect(beginwaterenvironmentprobes_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 beginwaterenvironmentprobes_handler_id;

// subscribe to the BeginWaterEnvironmentProbes event with a lambda handler function and keeping connection ID
beginwaterenvironmentprobes_handler_id = publisher->getEventBeginWaterEnvironmentProbes().connect([]() { 
		Log::message("\Handling BeginWaterEnvironmentProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginWaterEnvironmentProbes().disconnect(beginwaterenvironmentprobes_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWaterEnvironmentProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginWaterEnvironmentProbes().setEnabled(true);

Return value

Event reference.

Event<> getEventEndWaterVoxelProbes() const#

event triggered after the water voxel probes rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndWaterVoxelProbes event handler
void endwatervoxelprobes_event_handler()
{
	Log::message("\Handling EndWaterVoxelProbes 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 endwatervoxelprobes_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWaterVoxelProbes().connect(endwatervoxelprobes_event_connections, endwatervoxelprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWaterVoxelProbes().connect(endwatervoxelprobes_event_connections, []() { 
		Log::message("\Handling EndWaterVoxelProbes event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endwatervoxelprobes_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 endwatervoxelprobes_event_connection;

// subscribe to the EndWaterVoxelProbes event with a handler function keeping the connection
publisher->getEventEndWaterVoxelProbes().connect(endwatervoxelprobes_event_connection, endwatervoxelprobes_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndWaterVoxelProbes event via the connection
endwatervoxelprobes_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 EndWaterVoxelProbes event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndWaterVoxelProbes event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWaterVoxelProbes().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 EndWaterVoxelProbes event with a handler function
publisher->getEventEndWaterVoxelProbes().connect(endwatervoxelprobes_event_handler);


// remove subscription to the EndWaterVoxelProbes event later by the handler function
publisher->getEventEndWaterVoxelProbes().disconnect(endwatervoxelprobes_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 endwatervoxelprobes_handler_id;

// subscribe to the EndWaterVoxelProbes event with a lambda handler function and keeping connection ID
endwatervoxelprobes_handler_id = publisher->getEventEndWaterVoxelProbes().connect([]() { 
		Log::message("\Handling EndWaterVoxelProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndWaterVoxelProbes().disconnect(endwatervoxelprobes_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWaterVoxelProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndWaterVoxelProbes().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginWaterVoxelProbes() const#

event triggered before the water voxel probes rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginWaterVoxelProbes event handler
void beginwatervoxelprobes_event_handler()
{
	Log::message("\Handling BeginWaterVoxelProbes 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 beginwatervoxelprobes_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWaterVoxelProbes().connect(beginwatervoxelprobes_event_connections, beginwatervoxelprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWaterVoxelProbes().connect(beginwatervoxelprobes_event_connections, []() { 
		Log::message("\Handling BeginWaterVoxelProbes event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginwatervoxelprobes_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 beginwatervoxelprobes_event_connection;

// subscribe to the BeginWaterVoxelProbes event with a handler function keeping the connection
publisher->getEventBeginWaterVoxelProbes().connect(beginwatervoxelprobes_event_connection, beginwatervoxelprobes_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginWaterVoxelProbes event via the connection
beginwatervoxelprobes_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 BeginWaterVoxelProbes event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginWaterVoxelProbes event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWaterVoxelProbes().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 BeginWaterVoxelProbes event with a handler function
publisher->getEventBeginWaterVoxelProbes().connect(beginwatervoxelprobes_event_handler);


// remove subscription to the BeginWaterVoxelProbes event later by the handler function
publisher->getEventBeginWaterVoxelProbes().disconnect(beginwatervoxelprobes_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 beginwatervoxelprobes_handler_id;

// subscribe to the BeginWaterVoxelProbes event with a lambda handler function and keeping connection ID
beginwatervoxelprobes_handler_id = publisher->getEventBeginWaterVoxelProbes().connect([]() { 
		Log::message("\Handling BeginWaterVoxelProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginWaterVoxelProbes().disconnect(beginwatervoxelprobes_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWaterVoxelProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginWaterVoxelProbes().setEnabled(true);

Return value

Event reference.

Event<> getEventEndWaterLights() const#

event triggered after the water lights rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndWaterLights event handler
void endwaterlights_event_handler()
{
	Log::message("\Handling EndWaterLights 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 endwaterlights_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWaterLights().connect(endwaterlights_event_connections, endwaterlights_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWaterLights().connect(endwaterlights_event_connections, []() { 
		Log::message("\Handling EndWaterLights event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endwaterlights_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 endwaterlights_event_connection;

// subscribe to the EndWaterLights event with a handler function keeping the connection
publisher->getEventEndWaterLights().connect(endwaterlights_event_connection, endwaterlights_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndWaterLights event via the connection
endwaterlights_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 EndWaterLights event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndWaterLights event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWaterLights().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 EndWaterLights event with a handler function
publisher->getEventEndWaterLights().connect(endwaterlights_event_handler);


// remove subscription to the EndWaterLights event later by the handler function
publisher->getEventEndWaterLights().disconnect(endwaterlights_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 endwaterlights_handler_id;

// subscribe to the EndWaterLights event with a lambda handler function and keeping connection ID
endwaterlights_handler_id = publisher->getEventEndWaterLights().connect([]() { 
		Log::message("\Handling EndWaterLights event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndWaterLights().disconnect(endwaterlights_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWaterLights().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndWaterLights().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginWaterLights() const#

event triggered before the water lights rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginWaterLights event handler
void beginwaterlights_event_handler()
{
	Log::message("\Handling BeginWaterLights 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 beginwaterlights_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWaterLights().connect(beginwaterlights_event_connections, beginwaterlights_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWaterLights().connect(beginwaterlights_event_connections, []() { 
		Log::message("\Handling BeginWaterLights event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginwaterlights_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 beginwaterlights_event_connection;

// subscribe to the BeginWaterLights event with a handler function keeping the connection
publisher->getEventBeginWaterLights().connect(beginwaterlights_event_connection, beginwaterlights_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginWaterLights event via the connection
beginwaterlights_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 BeginWaterLights event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginWaterLights event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWaterLights().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 BeginWaterLights event with a handler function
publisher->getEventBeginWaterLights().connect(beginwaterlights_event_handler);


// remove subscription to the BeginWaterLights event later by the handler function
publisher->getEventBeginWaterLights().disconnect(beginwaterlights_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 beginwaterlights_handler_id;

// subscribe to the BeginWaterLights event with a lambda handler function and keeping connection ID
beginwaterlights_handler_id = publisher->getEventBeginWaterLights().connect([]() { 
		Log::message("\Handling BeginWaterLights event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginWaterLights().disconnect(beginwaterlights_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWaterLights().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginWaterLights().setEnabled(true);

Return value

Event reference.

Event<> getEventEndWaterDecals() const#

event triggered after the water decals rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndWaterDecals event handler
void endwaterdecals_event_handler()
{
	Log::message("\Handling EndWaterDecals 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 endwaterdecals_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWaterDecals().connect(endwaterdecals_event_connections, endwaterdecals_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWaterDecals().connect(endwaterdecals_event_connections, []() { 
		Log::message("\Handling EndWaterDecals event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endwaterdecals_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 endwaterdecals_event_connection;

// subscribe to the EndWaterDecals event with a handler function keeping the connection
publisher->getEventEndWaterDecals().connect(endwaterdecals_event_connection, endwaterdecals_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndWaterDecals event via the connection
endwaterdecals_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 EndWaterDecals event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndWaterDecals event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWaterDecals().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 EndWaterDecals event with a handler function
publisher->getEventEndWaterDecals().connect(endwaterdecals_event_handler);


// remove subscription to the EndWaterDecals event later by the handler function
publisher->getEventEndWaterDecals().disconnect(endwaterdecals_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 endwaterdecals_handler_id;

// subscribe to the EndWaterDecals event with a lambda handler function and keeping connection ID
endwaterdecals_handler_id = publisher->getEventEndWaterDecals().connect([]() { 
		Log::message("\Handling EndWaterDecals event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndWaterDecals().disconnect(endwaterdecals_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWaterDecals().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndWaterDecals().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginWaterDecals() const#

event triggered before the water decals rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginWaterDecals event handler
void beginwaterdecals_event_handler()
{
	Log::message("\Handling BeginWaterDecals 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 beginwaterdecals_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWaterDecals().connect(beginwaterdecals_event_connections, beginwaterdecals_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWaterDecals().connect(beginwaterdecals_event_connections, []() { 
		Log::message("\Handling BeginWaterDecals event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginwaterdecals_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 beginwaterdecals_event_connection;

// subscribe to the BeginWaterDecals event with a handler function keeping the connection
publisher->getEventBeginWaterDecals().connect(beginwaterdecals_event_connection, beginwaterdecals_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginWaterDecals event via the connection
beginwaterdecals_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 BeginWaterDecals event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginWaterDecals event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWaterDecals().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 BeginWaterDecals event with a handler function
publisher->getEventBeginWaterDecals().connect(beginwaterdecals_event_handler);


// remove subscription to the BeginWaterDecals event later by the handler function
publisher->getEventBeginWaterDecals().disconnect(beginwaterdecals_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 beginwaterdecals_handler_id;

// subscribe to the BeginWaterDecals event with a lambda handler function and keeping connection ID
beginwaterdecals_handler_id = publisher->getEventBeginWaterDecals().connect([]() { 
		Log::message("\Handling BeginWaterDecals event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginWaterDecals().disconnect(beginwaterdecals_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWaterDecals().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginWaterDecals().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginWater() const#

event triggered before the water rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginWater event handler
void beginwater_event_handler()
{
	Log::message("\Handling BeginWater 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 beginwater_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWater().connect(beginwater_event_connections, beginwater_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWater().connect(beginwater_event_connections, []() { 
		Log::message("\Handling BeginWater event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginwater_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 beginwater_event_connection;

// subscribe to the BeginWater event with a handler function keeping the connection
publisher->getEventBeginWater().connect(beginwater_event_connection, beginwater_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginWater event via the connection
beginwater_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 BeginWater event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginWater event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWater().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 BeginWater event with a handler function
publisher->getEventBeginWater().connect(beginwater_event_handler);


// remove subscription to the BeginWater event later by the handler function
publisher->getEventBeginWater().disconnect(beginwater_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 beginwater_handler_id;

// subscribe to the BeginWater event with a lambda handler function and keeping connection ID
beginwater_handler_id = publisher->getEventBeginWater().connect([]() { 
		Log::message("\Handling BeginWater event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginWater().disconnect(beginwater_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWater().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginWater().setEnabled(true);

Return value

Event reference.

Event<> getEventEndClouds() const#

event triggered after the clouds rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndClouds event handler
void endclouds_event_handler()
{
	Log::message("\Handling EndClouds 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 endclouds_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndClouds().connect(endclouds_event_connections, endclouds_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndClouds().connect(endclouds_event_connections, []() { 
		Log::message("\Handling EndClouds event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endclouds_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 endclouds_event_connection;

// subscribe to the EndClouds event with a handler function keeping the connection
publisher->getEventEndClouds().connect(endclouds_event_connection, endclouds_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndClouds event via the connection
endclouds_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 EndClouds event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndClouds event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndClouds().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 EndClouds event with a handler function
publisher->getEventEndClouds().connect(endclouds_event_handler);


// remove subscription to the EndClouds event later by the handler function
publisher->getEventEndClouds().disconnect(endclouds_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 endclouds_handler_id;

// subscribe to the EndClouds event with a lambda handler function and keeping connection ID
endclouds_handler_id = publisher->getEventEndClouds().connect([]() { 
		Log::message("\Handling EndClouds event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndClouds().disconnect(endclouds_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndClouds().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndClouds().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginClouds() const#

event triggered before the clouds rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginClouds event handler
void beginclouds_event_handler()
{
	Log::message("\Handling BeginClouds 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 beginclouds_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginClouds().connect(beginclouds_event_connections, beginclouds_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginClouds().connect(beginclouds_event_connections, []() { 
		Log::message("\Handling BeginClouds event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginclouds_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 beginclouds_event_connection;

// subscribe to the BeginClouds event with a handler function keeping the connection
publisher->getEventBeginClouds().connect(beginclouds_event_connection, beginclouds_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginClouds event via the connection
beginclouds_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 BeginClouds event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginClouds event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginClouds().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 BeginClouds event with a handler function
publisher->getEventBeginClouds().connect(beginclouds_event_handler);


// remove subscription to the BeginClouds event later by the handler function
publisher->getEventBeginClouds().disconnect(beginclouds_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 beginclouds_handler_id;

// subscribe to the BeginClouds event with a lambda handler function and keeping connection ID
beginclouds_handler_id = publisher->getEventBeginClouds().connect([]() { 
		Log::message("\Handling BeginClouds event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginClouds().disconnect(beginclouds_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginClouds().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginClouds().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginTransparent() const#

event triggered before the transparent objects rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginTransparent event handler
void begintransparent_event_handler()
{
	Log::message("\Handling BeginTransparent 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 begintransparent_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginTransparent().connect(begintransparent_event_connections, begintransparent_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginTransparent().connect(begintransparent_event_connections, []() { 
		Log::message("\Handling BeginTransparent event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
begintransparent_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 begintransparent_event_connection;

// subscribe to the BeginTransparent event with a handler function keeping the connection
publisher->getEventBeginTransparent().connect(begintransparent_event_connection, begintransparent_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginTransparent event via the connection
begintransparent_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 BeginTransparent event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginTransparent event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginTransparent().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 BeginTransparent event with a handler function
publisher->getEventBeginTransparent().connect(begintransparent_event_handler);


// remove subscription to the BeginTransparent event later by the handler function
publisher->getEventBeginTransparent().disconnect(begintransparent_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 begintransparent_handler_id;

// subscribe to the BeginTransparent event with a lambda handler function and keeping connection ID
begintransparent_handler_id = publisher->getEventBeginTransparent().connect([]() { 
		Log::message("\Handling BeginTransparent event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginTransparent().disconnect(begintransparent_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginTransparent().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginTransparent().setEnabled(true);

Return value

Event reference.

Event<> getEventEndCompositeDeferred() const#

event triggered after the clouds deferred composite stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndCompositeDeferred event handler
void endcompositedeferred_event_handler()
{
	Log::message("\Handling EndCompositeDeferred 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 endcompositedeferred_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndCompositeDeferred().connect(endcompositedeferred_event_connections, endcompositedeferred_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndCompositeDeferred().connect(endcompositedeferred_event_connections, []() { 
		Log::message("\Handling EndCompositeDeferred event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endcompositedeferred_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 endcompositedeferred_event_connection;

// subscribe to the EndCompositeDeferred event with a handler function keeping the connection
publisher->getEventEndCompositeDeferred().connect(endcompositedeferred_event_connection, endcompositedeferred_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndCompositeDeferred event via the connection
endcompositedeferred_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 EndCompositeDeferred event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndCompositeDeferred event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndCompositeDeferred().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 EndCompositeDeferred event with a handler function
publisher->getEventEndCompositeDeferred().connect(endcompositedeferred_event_handler);


// remove subscription to the EndCompositeDeferred event later by the handler function
publisher->getEventEndCompositeDeferred().disconnect(endcompositedeferred_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 endcompositedeferred_handler_id;

// subscribe to the EndCompositeDeferred event with a lambda handler function and keeping connection ID
endcompositedeferred_handler_id = publisher->getEventEndCompositeDeferred().connect([]() { 
		Log::message("\Handling EndCompositeDeferred event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndCompositeDeferred().disconnect(endcompositedeferred_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndCompositeDeferred().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndCompositeDeferred().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginCompositeDeferred() const#

event triggered before the clouds deferred composite stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginCompositeDeferred event handler
void begincompositedeferred_event_handler()
{
	Log::message("\Handling BeginCompositeDeferred 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 begincompositedeferred_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginCompositeDeferred().connect(begincompositedeferred_event_connections, begincompositedeferred_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginCompositeDeferred().connect(begincompositedeferred_event_connections, []() { 
		Log::message("\Handling BeginCompositeDeferred event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
begincompositedeferred_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 begincompositedeferred_event_connection;

// subscribe to the BeginCompositeDeferred event with a handler function keeping the connection
publisher->getEventBeginCompositeDeferred().connect(begincompositedeferred_event_connection, begincompositedeferred_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginCompositeDeferred event via the connection
begincompositedeferred_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 BeginCompositeDeferred event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginCompositeDeferred event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginCompositeDeferred().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 BeginCompositeDeferred event with a handler function
publisher->getEventBeginCompositeDeferred().connect(begincompositedeferred_event_handler);


// remove subscription to the BeginCompositeDeferred event later by the handler function
publisher->getEventBeginCompositeDeferred().disconnect(begincompositedeferred_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 begincompositedeferred_handler_id;

// subscribe to the BeginCompositeDeferred event with a lambda handler function and keeping connection ID
begincompositedeferred_handler_id = publisher->getEventBeginCompositeDeferred().connect([]() { 
		Log::message("\Handling BeginCompositeDeferred event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginCompositeDeferred().disconnect(begincompositedeferred_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginCompositeDeferred().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginCompositeDeferred().setEnabled(true);

Return value

Event reference.

Event<> getEventEndSky() const#

event triggered after the sky rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndSky event handler
void endsky_event_handler()
{
	Log::message("\Handling EndSky 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 endsky_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSky().connect(endsky_event_connections, endsky_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSky().connect(endsky_event_connections, []() { 
		Log::message("\Handling EndSky event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endsky_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 endsky_event_connection;

// subscribe to the EndSky event with a handler function keeping the connection
publisher->getEventEndSky().connect(endsky_event_connection, endsky_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndSky event via the connection
endsky_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 EndSky event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndSky event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSky().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 EndSky event with a handler function
publisher->getEventEndSky().connect(endsky_event_handler);


// remove subscription to the EndSky event later by the handler function
publisher->getEventEndSky().disconnect(endsky_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 endsky_handler_id;

// subscribe to the EndSky event with a lambda handler function and keeping connection ID
endsky_handler_id = publisher->getEventEndSky().connect([]() { 
		Log::message("\Handling EndSky event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndSky().disconnect(endsky_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSky().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndSky().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginSky() const#

event triggered before the sky rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginSky event handler
void beginsky_event_handler()
{
	Log::message("\Handling BeginSky 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 beginsky_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSky().connect(beginsky_event_connections, beginsky_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSky().connect(beginsky_event_connections, []() { 
		Log::message("\Handling BeginSky event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginsky_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 beginsky_event_connection;

// subscribe to the BeginSky event with a handler function keeping the connection
publisher->getEventBeginSky().connect(beginsky_event_connection, beginsky_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginSky event via the connection
beginsky_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 BeginSky event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginSky event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSky().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 BeginSky event with a handler function
publisher->getEventBeginSky().connect(beginsky_event_handler);


// remove subscription to the BeginSky event later by the handler function
publisher->getEventBeginSky().disconnect(beginsky_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 beginsky_handler_id;

// subscribe to the BeginSky event with a lambda handler function and keeping connection ID
beginsky_handler_id = publisher->getEventBeginSky().connect([]() { 
		Log::message("\Handling BeginSky event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginSky().disconnect(beginsky_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSky().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginSky().setEnabled(true);

Return value

Event reference.

Event<> getEventEndSSGI() const#

event triggered after the SSGI rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndSSGI event handler
void endssgi_event_handler()
{
	Log::message("\Handling EndSSGI 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 endssgi_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSSGI().connect(endssgi_event_connections, endssgi_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSSGI().connect(endssgi_event_connections, []() { 
		Log::message("\Handling EndSSGI event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endssgi_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 endssgi_event_connection;

// subscribe to the EndSSGI event with a handler function keeping the connection
publisher->getEventEndSSGI().connect(endssgi_event_connection, endssgi_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndSSGI event via the connection
endssgi_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 EndSSGI event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndSSGI event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSSGI().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 EndSSGI event with a handler function
publisher->getEventEndSSGI().connect(endssgi_event_handler);


// remove subscription to the EndSSGI event later by the handler function
publisher->getEventEndSSGI().disconnect(endssgi_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 endssgi_handler_id;

// subscribe to the EndSSGI event with a lambda handler function and keeping connection ID
endssgi_handler_id = publisher->getEventEndSSGI().connect([]() { 
		Log::message("\Handling EndSSGI event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndSSGI().disconnect(endssgi_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSSGI().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndSSGI().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginSSGI() const#

event triggered before the SSGI rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginSSGI event handler
void beginssgi_event_handler()
{
	Log::message("\Handling BeginSSGI 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 beginssgi_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSSGI().connect(beginssgi_event_connections, beginssgi_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSSGI().connect(beginssgi_event_connections, []() { 
		Log::message("\Handling BeginSSGI event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginssgi_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 beginssgi_event_connection;

// subscribe to the BeginSSGI event with a handler function keeping the connection
publisher->getEventBeginSSGI().connect(beginssgi_event_connection, beginssgi_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginSSGI event via the connection
beginssgi_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 BeginSSGI event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginSSGI event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSSGI().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 BeginSSGI event with a handler function
publisher->getEventBeginSSGI().connect(beginssgi_event_handler);


// remove subscription to the BeginSSGI event later by the handler function
publisher->getEventBeginSSGI().disconnect(beginssgi_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 beginssgi_handler_id;

// subscribe to the BeginSSGI event with a lambda handler function and keeping connection ID
beginssgi_handler_id = publisher->getEventBeginSSGI().connect([]() { 
		Log::message("\Handling BeginSSGI event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginSSGI().disconnect(beginssgi_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSSGI().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginSSGI().setEnabled(true);

Return value

Event reference.

Event<> getEventEndSSAO() const#

event triggered after the SSAO rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndSSAO event handler
void endssao_event_handler()
{
	Log::message("\Handling EndSSAO 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 endssao_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSSAO().connect(endssao_event_connections, endssao_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSSAO().connect(endssao_event_connections, []() { 
		Log::message("\Handling EndSSAO event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endssao_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 endssao_event_connection;

// subscribe to the EndSSAO event with a handler function keeping the connection
publisher->getEventEndSSAO().connect(endssao_event_connection, endssao_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndSSAO event via the connection
endssao_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 EndSSAO event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndSSAO event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSSAO().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 EndSSAO event with a handler function
publisher->getEventEndSSAO().connect(endssao_event_handler);


// remove subscription to the EndSSAO event later by the handler function
publisher->getEventEndSSAO().disconnect(endssao_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 endssao_handler_id;

// subscribe to the EndSSAO event with a lambda handler function and keeping connection ID
endssao_handler_id = publisher->getEventEndSSAO().connect([]() { 
		Log::message("\Handling EndSSAO event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndSSAO().disconnect(endssao_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSSAO().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndSSAO().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginSSAO() const#

event triggered before the SSAO rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginSSAO event handler
void beginssao_event_handler()
{
	Log::message("\Handling BeginSSAO 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 beginssao_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSSAO().connect(beginssao_event_connections, beginssao_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSSAO().connect(beginssao_event_connections, []() { 
		Log::message("\Handling BeginSSAO event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginssao_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 beginssao_event_connection;

// subscribe to the BeginSSAO event with a handler function keeping the connection
publisher->getEventBeginSSAO().connect(beginssao_event_connection, beginssao_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginSSAO event via the connection
beginssao_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 BeginSSAO event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginSSAO event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSSAO().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 BeginSSAO event with a handler function
publisher->getEventBeginSSAO().connect(beginssao_event_handler);


// remove subscription to the BeginSSAO event later by the handler function
publisher->getEventBeginSSAO().disconnect(beginssao_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 beginssao_handler_id;

// subscribe to the BeginSSAO event with a lambda handler function and keeping connection ID
beginssao_handler_id = publisher->getEventBeginSSAO().connect([]() { 
		Log::message("\Handling BeginSSAO event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginSSAO().disconnect(beginssao_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSSAO().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginSSAO().setEnabled(true);

Return value

Event reference.

Event<> getEventEndSSR() const#

event triggered after the SSR rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndSSR event handler
void endssr_event_handler()
{
	Log::message("\Handling EndSSR 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 endssr_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSSR().connect(endssr_event_connections, endssr_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSSR().connect(endssr_event_connections, []() { 
		Log::message("\Handling EndSSR event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endssr_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 endssr_event_connection;

// subscribe to the EndSSR event with a handler function keeping the connection
publisher->getEventEndSSR().connect(endssr_event_connection, endssr_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndSSR event via the connection
endssr_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 EndSSR event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndSSR event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSSR().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 EndSSR event with a handler function
publisher->getEventEndSSR().connect(endssr_event_handler);


// remove subscription to the EndSSR event later by the handler function
publisher->getEventEndSSR().disconnect(endssr_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 endssr_handler_id;

// subscribe to the EndSSR event with a lambda handler function and keeping connection ID
endssr_handler_id = publisher->getEventEndSSR().connect([]() { 
		Log::message("\Handling EndSSR event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndSSR().disconnect(endssr_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSSR().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndSSR().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginSSR() const#

event triggered before the SSR rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginSSR event handler
void beginssr_event_handler()
{
	Log::message("\Handling BeginSSR 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 beginssr_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSSR().connect(beginssr_event_connections, beginssr_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSSR().connect(beginssr_event_connections, []() { 
		Log::message("\Handling BeginSSR event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginssr_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 beginssr_event_connection;

// subscribe to the BeginSSR event with a handler function keeping the connection
publisher->getEventBeginSSR().connect(beginssr_event_connection, beginssr_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginSSR event via the connection
beginssr_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 BeginSSR event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginSSR event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSSR().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 BeginSSR event with a handler function
publisher->getEventBeginSSR().connect(beginssr_event_handler);


// remove subscription to the BeginSSR event later by the handler function
publisher->getEventBeginSSR().disconnect(beginssr_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 beginssr_handler_id;

// subscribe to the BeginSSR event with a lambda handler function and keeping connection ID
beginssr_handler_id = publisher->getEventBeginSSR().connect([]() { 
		Log::message("\Handling BeginSSR event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginSSR().disconnect(beginssr_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSSR().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginSSR().setEnabled(true);

Return value

Event reference.

Event<> getEventEndSSSS() const#

event triggered after the Screen-Space Shadow Shafts rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndSSSS event handler
void endssss_event_handler()
{
	Log::message("\Handling EndSSSS 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 endssss_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSSSS().connect(endssss_event_connections, endssss_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSSSS().connect(endssss_event_connections, []() { 
		Log::message("\Handling EndSSSS event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endssss_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 endssss_event_connection;

// subscribe to the EndSSSS event with a handler function keeping the connection
publisher->getEventEndSSSS().connect(endssss_event_connection, endssss_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndSSSS event via the connection
endssss_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 EndSSSS event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndSSSS event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSSSS().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 EndSSSS event with a handler function
publisher->getEventEndSSSS().connect(endssss_event_handler);


// remove subscription to the EndSSSS event later by the handler function
publisher->getEventEndSSSS().disconnect(endssss_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 endssss_handler_id;

// subscribe to the EndSSSS event with a lambda handler function and keeping connection ID
endssss_handler_id = publisher->getEventEndSSSS().connect([]() { 
		Log::message("\Handling EndSSSS event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndSSSS().disconnect(endssss_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSSSS().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndSSSS().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginSSSS() const#

event triggered before the Screen-Space Shadow Shafts rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginSSSS event handler
void beginssss_event_handler()
{
	Log::message("\Handling BeginSSSS 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 beginssss_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSSSS().connect(beginssss_event_connections, beginssss_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSSSS().connect(beginssss_event_connections, []() { 
		Log::message("\Handling BeginSSSS event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginssss_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 beginssss_event_connection;

// subscribe to the BeginSSSS event with a handler function keeping the connection
publisher->getEventBeginSSSS().connect(beginssss_event_connection, beginssss_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginSSSS event via the connection
beginssss_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 BeginSSSS event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginSSSS event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSSSS().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 BeginSSSS event with a handler function
publisher->getEventBeginSSSS().connect(beginssss_event_handler);


// remove subscription to the BeginSSSS event later by the handler function
publisher->getEventBeginSSSS().disconnect(beginssss_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 beginssss_handler_id;

// subscribe to the BeginSSSS event with a lambda handler function and keeping connection ID
beginssss_handler_id = publisher->getEventBeginSSSS().connect([]() { 
		Log::message("\Handling BeginSSSS event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginSSSS().disconnect(beginssss_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSSSS().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginSSSS().setEnabled(true);

Return value

Event reference.

Event<> getEventEndTransparentBlurBuffer() const#

event triggered after filling the transparent blur buffer. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndTransparentBlurBuffer event handler
void endtransparentblurbuffer_event_handler()
{
	Log::message("\Handling EndTransparentBlurBuffer 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 endtransparentblurbuffer_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndTransparentBlurBuffer().connect(endtransparentblurbuffer_event_connections, endtransparentblurbuffer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndTransparentBlurBuffer().connect(endtransparentblurbuffer_event_connections, []() { 
		Log::message("\Handling EndTransparentBlurBuffer event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endtransparentblurbuffer_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 endtransparentblurbuffer_event_connection;

// subscribe to the EndTransparentBlurBuffer event with a handler function keeping the connection
publisher->getEventEndTransparentBlurBuffer().connect(endtransparentblurbuffer_event_connection, endtransparentblurbuffer_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndTransparentBlurBuffer event via the connection
endtransparentblurbuffer_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 EndTransparentBlurBuffer event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndTransparentBlurBuffer event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndTransparentBlurBuffer().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 EndTransparentBlurBuffer event with a handler function
publisher->getEventEndTransparentBlurBuffer().connect(endtransparentblurbuffer_event_handler);


// remove subscription to the EndTransparentBlurBuffer event later by the handler function
publisher->getEventEndTransparentBlurBuffer().disconnect(endtransparentblurbuffer_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 endtransparentblurbuffer_handler_id;

// subscribe to the EndTransparentBlurBuffer event with a lambda handler function and keeping connection ID
endtransparentblurbuffer_handler_id = publisher->getEventEndTransparentBlurBuffer().connect([]() { 
		Log::message("\Handling EndTransparentBlurBuffer event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndTransparentBlurBuffer().disconnect(endtransparentblurbuffer_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndTransparentBlurBuffer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndTransparentBlurBuffer().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginTransparentBlurBuffer() const#

event triggered before filling the transparent blur buffer. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginTransparentBlurBuffer event handler
void begintransparentblurbuffer_event_handler()
{
	Log::message("\Handling BeginTransparentBlurBuffer 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 begintransparentblurbuffer_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginTransparentBlurBuffer().connect(begintransparentblurbuffer_event_connections, begintransparentblurbuffer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginTransparentBlurBuffer().connect(begintransparentblurbuffer_event_connections, []() { 
		Log::message("\Handling BeginTransparentBlurBuffer event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
begintransparentblurbuffer_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 begintransparentblurbuffer_event_connection;

// subscribe to the BeginTransparentBlurBuffer event with a handler function keeping the connection
publisher->getEventBeginTransparentBlurBuffer().connect(begintransparentblurbuffer_event_connection, begintransparentblurbuffer_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginTransparentBlurBuffer event via the connection
begintransparentblurbuffer_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 BeginTransparentBlurBuffer event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginTransparentBlurBuffer event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginTransparentBlurBuffer().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 BeginTransparentBlurBuffer event with a handler function
publisher->getEventBeginTransparentBlurBuffer().connect(begintransparentblurbuffer_event_handler);


// remove subscription to the BeginTransparentBlurBuffer event later by the handler function
publisher->getEventBeginTransparentBlurBuffer().disconnect(begintransparentblurbuffer_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 begintransparentblurbuffer_handler_id;

// subscribe to the BeginTransparentBlurBuffer event with a lambda handler function and keeping connection ID
begintransparentblurbuffer_handler_id = publisher->getEventBeginTransparentBlurBuffer().connect([]() { 
		Log::message("\Handling BeginTransparentBlurBuffer event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginTransparentBlurBuffer().disconnect(begintransparentblurbuffer_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginTransparentBlurBuffer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginTransparentBlurBuffer().setEnabled(true);

Return value

Event reference.

Event<> getEventEndRefractionBuffer() const#

event triggered after filling the refraction buffer. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndRefractionBuffer event handler
void endrefractionbuffer_event_handler()
{
	Log::message("\Handling EndRefractionBuffer 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 endrefractionbuffer_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndRefractionBuffer().connect(endrefractionbuffer_event_connections, endrefractionbuffer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndRefractionBuffer().connect(endrefractionbuffer_event_connections, []() { 
		Log::message("\Handling EndRefractionBuffer event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endrefractionbuffer_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 endrefractionbuffer_event_connection;

// subscribe to the EndRefractionBuffer event with a handler function keeping the connection
publisher->getEventEndRefractionBuffer().connect(endrefractionbuffer_event_connection, endrefractionbuffer_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndRefractionBuffer event via the connection
endrefractionbuffer_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 EndRefractionBuffer event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndRefractionBuffer event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndRefractionBuffer().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 EndRefractionBuffer event with a handler function
publisher->getEventEndRefractionBuffer().connect(endrefractionbuffer_event_handler);


// remove subscription to the EndRefractionBuffer event later by the handler function
publisher->getEventEndRefractionBuffer().disconnect(endrefractionbuffer_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 endrefractionbuffer_handler_id;

// subscribe to the EndRefractionBuffer event with a lambda handler function and keeping connection ID
endrefractionbuffer_handler_id = publisher->getEventEndRefractionBuffer().connect([]() { 
		Log::message("\Handling EndRefractionBuffer event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndRefractionBuffer().disconnect(endrefractionbuffer_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndRefractionBuffer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndRefractionBuffer().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginRefractionBuffer() const#

event triggered before filling the refraction buffer. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginRefractionBuffer event handler
void beginrefractionbuffer_event_handler()
{
	Log::message("\Handling BeginRefractionBuffer 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 beginrefractionbuffer_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginRefractionBuffer().connect(beginrefractionbuffer_event_connections, beginrefractionbuffer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginRefractionBuffer().connect(beginrefractionbuffer_event_connections, []() { 
		Log::message("\Handling BeginRefractionBuffer event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginrefractionbuffer_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 beginrefractionbuffer_event_connection;

// subscribe to the BeginRefractionBuffer event with a handler function keeping the connection
publisher->getEventBeginRefractionBuffer().connect(beginrefractionbuffer_event_connection, beginrefractionbuffer_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginRefractionBuffer event via the connection
beginrefractionbuffer_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 BeginRefractionBuffer event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginRefractionBuffer event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginRefractionBuffer().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 BeginRefractionBuffer event with a handler function
publisher->getEventBeginRefractionBuffer().connect(beginrefractionbuffer_event_handler);


// remove subscription to the BeginRefractionBuffer event later by the handler function
publisher->getEventBeginRefractionBuffer().disconnect(beginrefractionbuffer_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 beginrefractionbuffer_handler_id;

// subscribe to the BeginRefractionBuffer event with a lambda handler function and keeping connection ID
beginrefractionbuffer_handler_id = publisher->getEventBeginRefractionBuffer().connect([]() { 
		Log::message("\Handling BeginRefractionBuffer event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginRefractionBuffer().disconnect(beginrefractionbuffer_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginRefractionBuffer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginRefractionBuffer().setEnabled(true);

Return value

Event reference.

Event<> getEventEndAuxiliaryBuffer() const#

event triggered after filling the auxiliary buffer. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndAuxiliaryBuffer event handler
void endauxiliarybuffer_event_handler()
{
	Log::message("\Handling EndAuxiliaryBuffer 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 endauxiliarybuffer_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndAuxiliaryBuffer().connect(endauxiliarybuffer_event_connections, endauxiliarybuffer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndAuxiliaryBuffer().connect(endauxiliarybuffer_event_connections, []() { 
		Log::message("\Handling EndAuxiliaryBuffer event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endauxiliarybuffer_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 endauxiliarybuffer_event_connection;

// subscribe to the EndAuxiliaryBuffer event with a handler function keeping the connection
publisher->getEventEndAuxiliaryBuffer().connect(endauxiliarybuffer_event_connection, endauxiliarybuffer_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndAuxiliaryBuffer event via the connection
endauxiliarybuffer_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 EndAuxiliaryBuffer event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndAuxiliaryBuffer event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndAuxiliaryBuffer().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 EndAuxiliaryBuffer event with a handler function
publisher->getEventEndAuxiliaryBuffer().connect(endauxiliarybuffer_event_handler);


// remove subscription to the EndAuxiliaryBuffer event later by the handler function
publisher->getEventEndAuxiliaryBuffer().disconnect(endauxiliarybuffer_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 endauxiliarybuffer_handler_id;

// subscribe to the EndAuxiliaryBuffer event with a lambda handler function and keeping connection ID
endauxiliarybuffer_handler_id = publisher->getEventEndAuxiliaryBuffer().connect([]() { 
		Log::message("\Handling EndAuxiliaryBuffer event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndAuxiliaryBuffer().disconnect(endauxiliarybuffer_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndAuxiliaryBuffer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndAuxiliaryBuffer().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginAuxiliaryBuffer() const#

event triggered before filling the auxiliary buffer. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginAuxiliaryBuffer event handler
void beginauxiliarybuffer_event_handler()
{
	Log::message("\Handling BeginAuxiliaryBuffer 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 beginauxiliarybuffer_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginAuxiliaryBuffer().connect(beginauxiliarybuffer_event_connections, beginauxiliarybuffer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginAuxiliaryBuffer().connect(beginauxiliarybuffer_event_connections, []() { 
		Log::message("\Handling BeginAuxiliaryBuffer event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginauxiliarybuffer_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 beginauxiliarybuffer_event_connection;

// subscribe to the BeginAuxiliaryBuffer event with a handler function keeping the connection
publisher->getEventBeginAuxiliaryBuffer().connect(beginauxiliarybuffer_event_connection, beginauxiliarybuffer_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginAuxiliaryBuffer event via the connection
beginauxiliarybuffer_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 BeginAuxiliaryBuffer event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginAuxiliaryBuffer event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginAuxiliaryBuffer().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 BeginAuxiliaryBuffer event with a handler function
publisher->getEventBeginAuxiliaryBuffer().connect(beginauxiliarybuffer_event_handler);


// remove subscription to the BeginAuxiliaryBuffer event later by the handler function
publisher->getEventBeginAuxiliaryBuffer().disconnect(beginauxiliarybuffer_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 beginauxiliarybuffer_handler_id;

// subscribe to the BeginAuxiliaryBuffer event with a lambda handler function and keeping connection ID
beginauxiliarybuffer_handler_id = publisher->getEventBeginAuxiliaryBuffer().connect([]() { 
		Log::message("\Handling BeginAuxiliaryBuffer event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginAuxiliaryBuffer().disconnect(beginauxiliarybuffer_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginAuxiliaryBuffer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginAuxiliaryBuffer().setEnabled(true);

Return value

Event reference.

Event<> getEventEndOpacityPlanarProbes() const#

event triggered after the opacity planar probes rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndOpacityPlanarProbes event handler
void endopacityplanarprobes_event_handler()
{
	Log::message("\Handling EndOpacityPlanarProbes 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 endopacityplanarprobes_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndOpacityPlanarProbes().connect(endopacityplanarprobes_event_connections, endopacityplanarprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndOpacityPlanarProbes().connect(endopacityplanarprobes_event_connections, []() { 
		Log::message("\Handling EndOpacityPlanarProbes event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endopacityplanarprobes_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 endopacityplanarprobes_event_connection;

// subscribe to the EndOpacityPlanarProbes event with a handler function keeping the connection
publisher->getEventEndOpacityPlanarProbes().connect(endopacityplanarprobes_event_connection, endopacityplanarprobes_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndOpacityPlanarProbes event via the connection
endopacityplanarprobes_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 EndOpacityPlanarProbes event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndOpacityPlanarProbes event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndOpacityPlanarProbes().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 EndOpacityPlanarProbes event with a handler function
publisher->getEventEndOpacityPlanarProbes().connect(endopacityplanarprobes_event_handler);


// remove subscription to the EndOpacityPlanarProbes event later by the handler function
publisher->getEventEndOpacityPlanarProbes().disconnect(endopacityplanarprobes_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 endopacityplanarprobes_handler_id;

// subscribe to the EndOpacityPlanarProbes event with a lambda handler function and keeping connection ID
endopacityplanarprobes_handler_id = publisher->getEventEndOpacityPlanarProbes().connect([]() { 
		Log::message("\Handling EndOpacityPlanarProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndOpacityPlanarProbes().disconnect(endopacityplanarprobes_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndOpacityPlanarProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndOpacityPlanarProbes().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginOpacityPlanarProbes() const#

event triggered before the opacity planar probes rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginOpacityPlanarProbes event handler
void beginopacityplanarprobes_event_handler()
{
	Log::message("\Handling BeginOpacityPlanarProbes 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 beginopacityplanarprobes_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginOpacityPlanarProbes().connect(beginopacityplanarprobes_event_connections, beginopacityplanarprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginOpacityPlanarProbes().connect(beginopacityplanarprobes_event_connections, []() { 
		Log::message("\Handling BeginOpacityPlanarProbes event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginopacityplanarprobes_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 beginopacityplanarprobes_event_connection;

// subscribe to the BeginOpacityPlanarProbes event with a handler function keeping the connection
publisher->getEventBeginOpacityPlanarProbes().connect(beginopacityplanarprobes_event_connection, beginopacityplanarprobes_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginOpacityPlanarProbes event via the connection
beginopacityplanarprobes_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 BeginOpacityPlanarProbes event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginOpacityPlanarProbes event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginOpacityPlanarProbes().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 BeginOpacityPlanarProbes event with a handler function
publisher->getEventBeginOpacityPlanarProbes().connect(beginopacityplanarprobes_event_handler);


// remove subscription to the BeginOpacityPlanarProbes event later by the handler function
publisher->getEventBeginOpacityPlanarProbes().disconnect(beginopacityplanarprobes_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 beginopacityplanarprobes_handler_id;

// subscribe to the BeginOpacityPlanarProbes event with a lambda handler function and keeping connection ID
beginopacityplanarprobes_handler_id = publisher->getEventBeginOpacityPlanarProbes().connect([]() { 
		Log::message("\Handling BeginOpacityPlanarProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginOpacityPlanarProbes().disconnect(beginopacityplanarprobes_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginOpacityPlanarProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginOpacityPlanarProbes().setEnabled(true);

Return value

Event reference.

Event<> getEventEndOpacityEnvironmentProbes() const#

event triggered after the opacity environment probes rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndOpacityEnvironmentProbes event handler
void endopacityenvironmentprobes_event_handler()
{
	Log::message("\Handling EndOpacityEnvironmentProbes 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 endopacityenvironmentprobes_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndOpacityEnvironmentProbes().connect(endopacityenvironmentprobes_event_connections, endopacityenvironmentprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndOpacityEnvironmentProbes().connect(endopacityenvironmentprobes_event_connections, []() { 
		Log::message("\Handling EndOpacityEnvironmentProbes event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endopacityenvironmentprobes_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 endopacityenvironmentprobes_event_connection;

// subscribe to the EndOpacityEnvironmentProbes event with a handler function keeping the connection
publisher->getEventEndOpacityEnvironmentProbes().connect(endopacityenvironmentprobes_event_connection, endopacityenvironmentprobes_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndOpacityEnvironmentProbes event via the connection
endopacityenvironmentprobes_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 EndOpacityEnvironmentProbes event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndOpacityEnvironmentProbes event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndOpacityEnvironmentProbes().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 EndOpacityEnvironmentProbes event with a handler function
publisher->getEventEndOpacityEnvironmentProbes().connect(endopacityenvironmentprobes_event_handler);


// remove subscription to the EndOpacityEnvironmentProbes event later by the handler function
publisher->getEventEndOpacityEnvironmentProbes().disconnect(endopacityenvironmentprobes_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 endopacityenvironmentprobes_handler_id;

// subscribe to the EndOpacityEnvironmentProbes event with a lambda handler function and keeping connection ID
endopacityenvironmentprobes_handler_id = publisher->getEventEndOpacityEnvironmentProbes().connect([]() { 
		Log::message("\Handling EndOpacityEnvironmentProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndOpacityEnvironmentProbes().disconnect(endopacityenvironmentprobes_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndOpacityEnvironmentProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndOpacityEnvironmentProbes().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginOpacityEnvironmentProbes() const#

event triggered before the opacity environment probes rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginOpacityEnvironmentProbes event handler
void beginopacityenvironmentprobes_event_handler()
{
	Log::message("\Handling BeginOpacityEnvironmentProbes 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 beginopacityenvironmentprobes_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginOpacityEnvironmentProbes().connect(beginopacityenvironmentprobes_event_connections, beginopacityenvironmentprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginOpacityEnvironmentProbes().connect(beginopacityenvironmentprobes_event_connections, []() { 
		Log::message("\Handling BeginOpacityEnvironmentProbes event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginopacityenvironmentprobes_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 beginopacityenvironmentprobes_event_connection;

// subscribe to the BeginOpacityEnvironmentProbes event with a handler function keeping the connection
publisher->getEventBeginOpacityEnvironmentProbes().connect(beginopacityenvironmentprobes_event_connection, beginopacityenvironmentprobes_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginOpacityEnvironmentProbes event via the connection
beginopacityenvironmentprobes_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 BeginOpacityEnvironmentProbes event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginOpacityEnvironmentProbes event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginOpacityEnvironmentProbes().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 BeginOpacityEnvironmentProbes event with a handler function
publisher->getEventBeginOpacityEnvironmentProbes().connect(beginopacityenvironmentprobes_event_handler);


// remove subscription to the BeginOpacityEnvironmentProbes event later by the handler function
publisher->getEventBeginOpacityEnvironmentProbes().disconnect(beginopacityenvironmentprobes_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 beginopacityenvironmentprobes_handler_id;

// subscribe to the BeginOpacityEnvironmentProbes event with a lambda handler function and keeping connection ID
beginopacityenvironmentprobes_handler_id = publisher->getEventBeginOpacityEnvironmentProbes().connect([]() { 
		Log::message("\Handling BeginOpacityEnvironmentProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginOpacityEnvironmentProbes().disconnect(beginopacityenvironmentprobes_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginOpacityEnvironmentProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginOpacityEnvironmentProbes().setEnabled(true);

Return value

Event reference.

Event<> getEventEndOpacityVoxelProbes() const#

event triggered after the opacity voxel probes rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndOpacityVoxelProbes event handler
void endopacityvoxelprobes_event_handler()
{
	Log::message("\Handling EndOpacityVoxelProbes 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 endopacityvoxelprobes_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndOpacityVoxelProbes().connect(endopacityvoxelprobes_event_connections, endopacityvoxelprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndOpacityVoxelProbes().connect(endopacityvoxelprobes_event_connections, []() { 
		Log::message("\Handling EndOpacityVoxelProbes event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endopacityvoxelprobes_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 endopacityvoxelprobes_event_connection;

// subscribe to the EndOpacityVoxelProbes event with a handler function keeping the connection
publisher->getEventEndOpacityVoxelProbes().connect(endopacityvoxelprobes_event_connection, endopacityvoxelprobes_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndOpacityVoxelProbes event via the connection
endopacityvoxelprobes_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 EndOpacityVoxelProbes event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndOpacityVoxelProbes event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndOpacityVoxelProbes().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 EndOpacityVoxelProbes event with a handler function
publisher->getEventEndOpacityVoxelProbes().connect(endopacityvoxelprobes_event_handler);


// remove subscription to the EndOpacityVoxelProbes event later by the handler function
publisher->getEventEndOpacityVoxelProbes().disconnect(endopacityvoxelprobes_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 endopacityvoxelprobes_handler_id;

// subscribe to the EndOpacityVoxelProbes event with a lambda handler function and keeping connection ID
endopacityvoxelprobes_handler_id = publisher->getEventEndOpacityVoxelProbes().connect([]() { 
		Log::message("\Handling EndOpacityVoxelProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndOpacityVoxelProbes().disconnect(endopacityvoxelprobes_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndOpacityVoxelProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndOpacityVoxelProbes().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginOpacityVoxelProbes() const#

event triggered before the opacity voxel probes rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginOpacityVoxelProbes event handler
void beginopacityvoxelprobes_event_handler()
{
	Log::message("\Handling BeginOpacityVoxelProbes 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 beginopacityvoxelprobes_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginOpacityVoxelProbes().connect(beginopacityvoxelprobes_event_connections, beginopacityvoxelprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginOpacityVoxelProbes().connect(beginopacityvoxelprobes_event_connections, []() { 
		Log::message("\Handling BeginOpacityVoxelProbes event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginopacityvoxelprobes_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 beginopacityvoxelprobes_event_connection;

// subscribe to the BeginOpacityVoxelProbes event with a handler function keeping the connection
publisher->getEventBeginOpacityVoxelProbes().connect(beginopacityvoxelprobes_event_connection, beginopacityvoxelprobes_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginOpacityVoxelProbes event via the connection
beginopacityvoxelprobes_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 BeginOpacityVoxelProbes event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginOpacityVoxelProbes event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginOpacityVoxelProbes().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 BeginOpacityVoxelProbes event with a handler function
publisher->getEventBeginOpacityVoxelProbes().connect(beginopacityvoxelprobes_event_handler);


// remove subscription to the BeginOpacityVoxelProbes event later by the handler function
publisher->getEventBeginOpacityVoxelProbes().disconnect(beginopacityvoxelprobes_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 beginopacityvoxelprobes_handler_id;

// subscribe to the BeginOpacityVoxelProbes event with a lambda handler function and keeping connection ID
beginopacityvoxelprobes_handler_id = publisher->getEventBeginOpacityVoxelProbes().connect([]() { 
		Log::message("\Handling BeginOpacityVoxelProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginOpacityVoxelProbes().disconnect(beginopacityvoxelprobes_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginOpacityVoxelProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginOpacityVoxelProbes().setEnabled(true);

Return value

Event reference.

Event<> getEventEndOpacityLights() const#

event triggered after the opacity lightgs rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndOpacityLights event handler
void endopacitylights_event_handler()
{
	Log::message("\Handling EndOpacityLights 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 endopacitylights_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndOpacityLights().connect(endopacitylights_event_connections, endopacitylights_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndOpacityLights().connect(endopacitylights_event_connections, []() { 
		Log::message("\Handling EndOpacityLights event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endopacitylights_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 endopacitylights_event_connection;

// subscribe to the EndOpacityLights event with a handler function keeping the connection
publisher->getEventEndOpacityLights().connect(endopacitylights_event_connection, endopacitylights_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndOpacityLights event via the connection
endopacitylights_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 EndOpacityLights event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndOpacityLights event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndOpacityLights().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 EndOpacityLights event with a handler function
publisher->getEventEndOpacityLights().connect(endopacitylights_event_handler);


// remove subscription to the EndOpacityLights event later by the handler function
publisher->getEventEndOpacityLights().disconnect(endopacitylights_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 endopacitylights_handler_id;

// subscribe to the EndOpacityLights event with a lambda handler function and keeping connection ID
endopacitylights_handler_id = publisher->getEventEndOpacityLights().connect([]() { 
		Log::message("\Handling EndOpacityLights event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndOpacityLights().disconnect(endopacitylights_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndOpacityLights().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndOpacityLights().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginOpacityLights() const#

event triggered before the opacity lightgs rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginOpacityLights event handler
void beginopacitylights_event_handler()
{
	Log::message("\Handling BeginOpacityLights 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 beginopacitylights_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginOpacityLights().connect(beginopacitylights_event_connections, beginopacitylights_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginOpacityLights().connect(beginopacitylights_event_connections, []() { 
		Log::message("\Handling BeginOpacityLights event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginopacitylights_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 beginopacitylights_event_connection;

// subscribe to the BeginOpacityLights event with a handler function keeping the connection
publisher->getEventBeginOpacityLights().connect(beginopacitylights_event_connection, beginopacitylights_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginOpacityLights event via the connection
beginopacitylights_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 BeginOpacityLights event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginOpacityLights event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginOpacityLights().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 BeginOpacityLights event with a handler function
publisher->getEventBeginOpacityLights().connect(beginopacitylights_event_handler);


// remove subscription to the BeginOpacityLights event later by the handler function
publisher->getEventBeginOpacityLights().disconnect(beginopacitylights_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 beginopacitylights_handler_id;

// subscribe to the BeginOpacityLights event with a lambda handler function and keeping connection ID
beginopacitylights_handler_id = publisher->getEventBeginOpacityLights().connect([]() { 
		Log::message("\Handling BeginOpacityLights event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginOpacityLights().disconnect(beginopacitylights_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginOpacityLights().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginOpacityLights().setEnabled(true);

Return value

Event reference.

Event<> getEventEndSSRTGI() const#

event triggered after the SSRTGI rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndSSRTGI event handler
void endssrtgi_event_handler()
{
	Log::message("\Handling EndSSRTGI 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 endssrtgi_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSSRTGI().connect(endssrtgi_event_connections, endssrtgi_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSSRTGI().connect(endssrtgi_event_connections, []() { 
		Log::message("\Handling EndSSRTGI event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endssrtgi_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 endssrtgi_event_connection;

// subscribe to the EndSSRTGI event with a handler function keeping the connection
publisher->getEventEndSSRTGI().connect(endssrtgi_event_connection, endssrtgi_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the EndSSRTGI event via the connection
endssrtgi_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 EndSSRTGI event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndSSRTGI event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSSRTGI().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 EndSSRTGI event with a handler function
publisher->getEventEndSSRTGI().connect(endssrtgi_event_handler);


// remove subscription to the EndSSRTGI event later by the handler function
publisher->getEventEndSSRTGI().disconnect(endssrtgi_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 endssrtgi_handler_id;

// subscribe to the EndSSRTGI event with a lambda handler function and keeping connection ID
endssrtgi_handler_id = publisher->getEventEndSSRTGI().connect([]() { 
		Log::message("\Handling EndSSRTGI event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventEndSSRTGI().disconnect(endssrtgi_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSSRTGI().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventEndSSRTGI().setEnabled(true);

Return value

Event reference.

Event<> getEventBeginSSRTGI() const#

event triggered before the SSRTGI rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the BeginSSRTGI event handler
void beginssrtgi_event_handler()
{
	Log::message("\Handling BeginSSRTGI 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 beginssrtgi_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSSRTGI().connect(beginssrtgi_event_connections, beginssrtgi_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSSRTGI().connect(beginssrtgi_event_connections, []() { 
		Log::message("\Handling BeginSSRTGI event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginssrtgi_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 beginssrtgi_event_connection;

// subscribe to the BeginSSRTGI event with a handler function keeping the connection
publisher->getEventBeginSSRTGI().connect(beginssrtgi_event_connection, beginssrtgi_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the BeginSSRTGI event via the connection
beginssrtgi_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 BeginSSRTGI event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginSSRTGI event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSSRTGI().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 BeginSSRTGI event with a handler function
publisher->getEventBeginSSRTGI().connect(beginssrtgi_event_handler);


// remove subscription to the BeginSSRTGI event later by the handler function
publisher->getEventBeginSSRTGI().disconnect(beginssrtgi_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 beginssrtgi_handler_id;

// subscribe to the BeginSSRTGI event with a lambda handler function and keeping connection ID
beginssrtgi_handler_id = publisher->getEventBeginSSRTGI().connect([]() { 
		Log::message("\Handling BeginSSRTGI event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventBeginSSRTGI().disconnect(beginssrtgi_handler_id);


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

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSSRTGI().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventBeginSSRTGI().setEnabled(true);

Return value

Event reference.

Event<> getEventEndCurvatureComposite() const#

event triggered after the curvature rendering stage for the SSDirt effect. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the EndCurvatureComposite event handler
void endcurvaturecomposite_event_handler()
{
	Log::message("\Handling EndCurvatureComposite 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 endcurvaturecomposite_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndCurvatureComposite().connect(endcurvaturecomposite_event_connections, endcurvaturecomposite_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventEndCurvatureComposite().connect(endcurvaturecomposite_event_connections, []() { 
		Log::message("\Handling EndCurvatureComposite event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endcurvaturecomposite_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 endcurvaturecomposite_event_connection;

// subscribe