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).

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 for an event (subscription for various events can be linked)
viewport->getEventEnd().connect(end_event_connections, end_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the End event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the End event with a handler function
viewport->getEventEnd().connect(end_event_handler);


// remove subscription for the End event later by the handler function
viewport->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 for the End event with a lambda handler function and keeping connection ID
end_handler_id = viewport->getEventEnd().connect([]() { 
		Log::message("\Handling End event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEnd().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEnd().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndScreen().connect(endscreen_event_connections, endscreen_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndScreen event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndScreen event with a handler function
viewport->getEventEndScreen().connect(endscreen_event_handler);


// remove subscription for the EndScreen event later by the handler function
viewport->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 for the EndScreen event with a lambda handler function and keeping connection ID
endscreen_handler_id = viewport->getEventEndScreen().connect([]() { 
		Log::message("\Handling EndScreen event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndScreen().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndScreen().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndVisualizer().connect(endvisualizer_event_connections, endvisualizer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndVisualizer event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndVisualizer event with a handler function
viewport->getEventEndVisualizer().connect(endvisualizer_event_handler);


// remove subscription for the EndVisualizer event later by the handler function
viewport->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 for the EndVisualizer event with a lambda handler function and keeping connection ID
endvisualizer_handler_id = viewport->getEventEndVisualizer().connect([]() { 
		Log::message("\Handling EndVisualizer event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndVisualizer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndVisualizer().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginVisualizer().connect(beginvisualizer_event_connections, beginvisualizer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginVisualizer event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginVisualizer event with a handler function
viewport->getEventBeginVisualizer().connect(beginvisualizer_event_handler);


// remove subscription for the BeginVisualizer event later by the handler function
viewport->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 for the BeginVisualizer event with a lambda handler function and keeping connection ID
beginvisualizer_handler_id = viewport->getEventBeginVisualizer().connect([]() { 
		Log::message("\Handling BeginVisualizer event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginVisualizer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginVisualizer().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndDebugMaterials().connect(enddebugmaterials_event_connections, enddebugmaterials_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndDebugMaterials event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndDebugMaterials event with a handler function
viewport->getEventEndDebugMaterials().connect(enddebugmaterials_event_handler);


// remove subscription for the EndDebugMaterials event later by the handler function
viewport->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 for the EndDebugMaterials event with a lambda handler function and keeping connection ID
enddebugmaterials_handler_id = viewport->getEventEndDebugMaterials().connect([]() { 
		Log::message("\Handling EndDebugMaterials event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndDebugMaterials().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndDebugMaterials().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginDebugMaterials().connect(begindebugmaterials_event_connections, begindebugmaterials_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginDebugMaterials event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginDebugMaterials event with a handler function
viewport->getEventBeginDebugMaterials().connect(begindebugmaterials_event_handler);


// remove subscription for the BeginDebugMaterials event later by the handler function
viewport->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 for the BeginDebugMaterials event with a lambda handler function and keeping connection ID
begindebugmaterials_handler_id = viewport->getEventBeginDebugMaterials().connect([]() { 
		Log::message("\Handling BeginDebugMaterials event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginDebugMaterials().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginDebugMaterials().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndPostMaterials().connect(endpostmaterials_event_connections, endpostmaterials_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndPostMaterials event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndPostMaterials event with a handler function
viewport->getEventEndPostMaterials().connect(endpostmaterials_event_handler);


// remove subscription for the EndPostMaterials event later by the handler function
viewport->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 for the EndPostMaterials event with a lambda handler function and keeping connection ID
endpostmaterials_handler_id = viewport->getEventEndPostMaterials().connect([]() { 
		Log::message("\Handling EndPostMaterials event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndPostMaterials().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndPostMaterials().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginPostMaterials().connect(beginpostmaterials_event_connections, beginpostmaterials_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginPostMaterials event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginPostMaterials event with a handler function
viewport->getEventBeginPostMaterials().connect(beginpostmaterials_event_handler);


// remove subscription for the BeginPostMaterials event later by the handler function
viewport->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 for the BeginPostMaterials event with a lambda handler function and keeping connection ID
beginpostmaterials_handler_id = viewport->getEventBeginPostMaterials().connect([]() { 
		Log::message("\Handling BeginPostMaterials event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginPostMaterials().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginPostMaterials().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndCameraEffects().connect(endcameraeffects_event_connections, endcameraeffects_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndCameraEffects event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndCameraEffects event with a handler function
viewport->getEventEndCameraEffects().connect(endcameraeffects_event_handler);


// remove subscription for the EndCameraEffects event later by the handler function
viewport->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 for the EndCameraEffects event with a lambda handler function and keeping connection ID
endcameraeffects_handler_id = viewport->getEventEndCameraEffects().connect([]() { 
		Log::message("\Handling EndCameraEffects event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndCameraEffects().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndCameraEffects().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginCameraEffects().connect(begincameraeffects_event_connections, begincameraeffects_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginCameraEffects event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginCameraEffects event with a handler function
viewport->getEventBeginCameraEffects().connect(begincameraeffects_event_handler);


// remove subscription for the BeginCameraEffects event later by the handler function
viewport->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 for the BeginCameraEffects event with a lambda handler function and keeping connection ID
begincameraeffects_handler_id = viewport->getEventBeginCameraEffects().connect([]() { 
		Log::message("\Handling BeginCameraEffects event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginCameraEffects().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginCameraEffects().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndTAA().connect(endtaa_event_connections, endtaa_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndTAA event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndTAA event with a handler function
viewport->getEventEndTAA().connect(endtaa_event_handler);


// remove subscription for the EndTAA event later by the handler function
viewport->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 for the EndTAA event with a lambda handler function and keeping connection ID
endtaa_handler_id = viewport->getEventEndTAA().connect([]() { 
		Log::message("\Handling EndTAA event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndTAA().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndTAA().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginTAA().connect(begintaa_event_connections, begintaa_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginTAA event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginTAA event with a handler function
viewport->getEventBeginTAA().connect(begintaa_event_handler);


// remove subscription for the BeginTAA event later by the handler function
viewport->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 for the BeginTAA event with a lambda handler function and keeping connection ID
begintaa_handler_id = viewport->getEventBeginTAA().connect([]() { 
		Log::message("\Handling BeginTAA event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginTAA().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginTAA().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndAdaptationColor().connect(endadaptationcolor_event_connections, endadaptationcolor_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndAdaptationColor event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndAdaptationColor event with a handler function
viewport->getEventEndAdaptationColor().connect(endadaptationcolor_event_handler);


// remove subscription for the EndAdaptationColor event later by the handler function
viewport->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 for the EndAdaptationColor event with a lambda handler function and keeping connection ID
endadaptationcolor_handler_id = viewport->getEventEndAdaptationColor().connect([]() { 
		Log::message("\Handling EndAdaptationColor event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndAdaptationColor().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndAdaptationColor().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginAdaptationColor().connect(beginadaptationcolor_event_connections, beginadaptationcolor_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginAdaptationColor event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginAdaptationColor event with a handler function
viewport->getEventBeginAdaptationColor().connect(beginadaptationcolor_event_handler);


// remove subscription for the BeginAdaptationColor event later by the handler function
viewport->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 for the BeginAdaptationColor event with a lambda handler function and keeping connection ID
beginadaptationcolor_handler_id = viewport->getEventBeginAdaptationColor().connect([]() { 
		Log::message("\Handling BeginAdaptationColor event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginAdaptationColor().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginAdaptationColor().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndAdaptationColorAverage().connect(endadaptationcoloraverage_event_connections, endadaptationcoloraverage_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndAdaptationColorAverage event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndAdaptationColorAverage event with a handler function
viewport->getEventEndAdaptationColorAverage().connect(endadaptationcoloraverage_event_handler);


// remove subscription for the EndAdaptationColorAverage event later by the handler function
viewport->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 for the EndAdaptationColorAverage event with a lambda handler function and keeping connection ID
endadaptationcoloraverage_handler_id = viewport->getEventEndAdaptationColorAverage().connect([]() { 
		Log::message("\Handling EndAdaptationColorAverage event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndAdaptationColorAverage().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndAdaptationColorAverage().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginAdaptationColorAverage().connect(beginadaptationcoloraverage_event_connections, beginadaptationcoloraverage_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginAdaptationColorAverage event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginAdaptationColorAverage event with a handler function
viewport->getEventBeginAdaptationColorAverage().connect(beginadaptationcoloraverage_event_handler);


// remove subscription for the BeginAdaptationColorAverage event later by the handler function
viewport->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 for the BeginAdaptationColorAverage event with a lambda handler function and keeping connection ID
beginadaptationcoloraverage_handler_id = viewport->getEventBeginAdaptationColorAverage().connect([]() { 
		Log::message("\Handling BeginAdaptationColorAverage event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginAdaptationColorAverage().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginAdaptationColorAverage().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndSrgbCorrection().connect(endsrgbcorrection_event_connections, endsrgbcorrection_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndSrgbCorrection event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndSrgbCorrection event with a handler function
viewport->getEventEndSrgbCorrection().connect(endsrgbcorrection_event_handler);


// remove subscription for the EndSrgbCorrection event later by the handler function
viewport->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 for the EndSrgbCorrection event with a lambda handler function and keeping connection ID
endsrgbcorrection_handler_id = viewport->getEventEndSrgbCorrection().connect([]() { 
		Log::message("\Handling EndSrgbCorrection event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndSrgbCorrection().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndSrgbCorrection().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginSrgbCorrection().connect(beginsrgbcorrection_event_connections, beginsrgbcorrection_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginSrgbCorrection event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginSrgbCorrection event with a handler function
viewport->getEventBeginSrgbCorrection().connect(beginsrgbcorrection_event_handler);


// remove subscription for the BeginSrgbCorrection event later by the handler function
viewport->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 for the BeginSrgbCorrection event with a lambda handler function and keeping connection ID
beginsrgbcorrection_handler_id = viewport->getEventBeginSrgbCorrection().connect([]() { 
		Log::message("\Handling BeginSrgbCorrection event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginSrgbCorrection().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginSrgbCorrection().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndTransparent().connect(endtransparent_event_connections, endtransparent_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndTransparent event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndTransparent event with a handler function
viewport->getEventEndTransparent().connect(endtransparent_event_handler);


// remove subscription for the EndTransparent event later by the handler function
viewport->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 for the EndTransparent event with a lambda handler function and keeping connection ID
endtransparent_handler_id = viewport->getEventEndTransparent().connect([]() { 
		Log::message("\Handling EndTransparent event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndTransparent().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndTransparent().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndWater().connect(endwater_event_connections, endwater_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndWater event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndWater event with a handler function
viewport->getEventEndWater().connect(endwater_event_handler);


// remove subscription for the EndWater event later by the handler function
viewport->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 for the EndWater event with a lambda handler function and keeping connection ID
endwater_handler_id = viewport->getEventEndWater().connect([]() { 
		Log::message("\Handling EndWater event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndWater().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndWater().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndWaterPlanarProbes().connect(endwaterplanarprobes_event_connections, endwaterplanarprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndWaterPlanarProbes event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndWaterPlanarProbes event with a handler function
viewport->getEventEndWaterPlanarProbes().connect(endwaterplanarprobes_event_handler);


// remove subscription for the EndWaterPlanarProbes event later by the handler function
viewport->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 for the EndWaterPlanarProbes event with a lambda handler function and keeping connection ID
endwaterplanarprobes_handler_id = viewport->getEventEndWaterPlanarProbes().connect([]() { 
		Log::message("\Handling EndWaterPlanarProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndWaterPlanarProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndWaterPlanarProbes().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginWaterPlanarProbes().connect(beginwaterplanarprobes_event_connections, beginwaterplanarprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginWaterPlanarProbes event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginWaterPlanarProbes event with a handler function
viewport->getEventBeginWaterPlanarProbes().connect(beginwaterplanarprobes_event_handler);


// remove subscription for the BeginWaterPlanarProbes event later by the handler function
viewport->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 for the BeginWaterPlanarProbes event with a lambda handler function and keeping connection ID
beginwaterplanarprobes_handler_id = viewport->getEventBeginWaterPlanarProbes().connect([]() { 
		Log::message("\Handling BeginWaterPlanarProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginWaterPlanarProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginWaterPlanarProbes().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndWaterEnvironmentProbes().connect(endwaterenvironmentprobes_event_connections, endwaterenvironmentprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndWaterEnvironmentProbes event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndWaterEnvironmentProbes event with a handler function
viewport->getEventEndWaterEnvironmentProbes().connect(endwaterenvironmentprobes_event_handler);


// remove subscription for the EndWaterEnvironmentProbes event later by the handler function
viewport->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 for the EndWaterEnvironmentProbes event with a lambda handler function and keeping connection ID
endwaterenvironmentprobes_handler_id = viewport->getEventEndWaterEnvironmentProbes().connect([]() { 
		Log::message("\Handling EndWaterEnvironmentProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndWaterEnvironmentProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndWaterEnvironmentProbes().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginWaterEnvironmentProbes().connect(beginwaterenvironmentprobes_event_connections, beginwaterenvironmentprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginWaterEnvironmentProbes event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginWaterEnvironmentProbes event with a handler function
viewport->getEventBeginWaterEnvironmentProbes().connect(beginwaterenvironmentprobes_event_handler);


// remove subscription for the BeginWaterEnvironmentProbes event later by the handler function
viewport->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 for the BeginWaterEnvironmentProbes event with a lambda handler function and keeping connection ID
beginwaterenvironmentprobes_handler_id = viewport->getEventBeginWaterEnvironmentProbes().connect([]() { 
		Log::message("\Handling BeginWaterEnvironmentProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginWaterEnvironmentProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginWaterEnvironmentProbes().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndWaterVoxelProbes().connect(endwatervoxelprobes_event_connections, endwatervoxelprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndWaterVoxelProbes event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndWaterVoxelProbes event with a handler function
viewport->getEventEndWaterVoxelProbes().connect(endwatervoxelprobes_event_handler);


// remove subscription for the EndWaterVoxelProbes event later by the handler function
viewport->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 for the EndWaterVoxelProbes event with a lambda handler function and keeping connection ID
endwatervoxelprobes_handler_id = viewport->getEventEndWaterVoxelProbes().connect([]() { 
		Log::message("\Handling EndWaterVoxelProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndWaterVoxelProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndWaterVoxelProbes().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginWaterVoxelProbes().connect(beginwatervoxelprobes_event_connections, beginwatervoxelprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginWaterVoxelProbes event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginWaterVoxelProbes event with a handler function
viewport->getEventBeginWaterVoxelProbes().connect(beginwatervoxelprobes_event_handler);


// remove subscription for the BeginWaterVoxelProbes event later by the handler function
viewport->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 for the BeginWaterVoxelProbes event with a lambda handler function and keeping connection ID
beginwatervoxelprobes_handler_id = viewport->getEventBeginWaterVoxelProbes().connect([]() { 
		Log::message("\Handling BeginWaterVoxelProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginWaterVoxelProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginWaterVoxelProbes().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndWaterLights().connect(endwaterlights_event_connections, endwaterlights_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndWaterLights event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndWaterLights event with a handler function
viewport->getEventEndWaterLights().connect(endwaterlights_event_handler);


// remove subscription for the EndWaterLights event later by the handler function
viewport->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 for the EndWaterLights event with a lambda handler function and keeping connection ID
endwaterlights_handler_id = viewport->getEventEndWaterLights().connect([]() { 
		Log::message("\Handling EndWaterLights event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndWaterLights().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndWaterLights().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginWaterLights().connect(beginwaterlights_event_connections, beginwaterlights_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginWaterLights event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginWaterLights event with a handler function
viewport->getEventBeginWaterLights().connect(beginwaterlights_event_handler);


// remove subscription for the BeginWaterLights event later by the handler function
viewport->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 for the BeginWaterLights event with a lambda handler function and keeping connection ID
beginwaterlights_handler_id = viewport->getEventBeginWaterLights().connect([]() { 
		Log::message("\Handling BeginWaterLights event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginWaterLights().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginWaterLights().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndWaterDecals().connect(endwaterdecals_event_connections, endwaterdecals_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndWaterDecals event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndWaterDecals event with a handler function
viewport->getEventEndWaterDecals().connect(endwaterdecals_event_handler);


// remove subscription for the EndWaterDecals event later by the handler function
viewport->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 for the EndWaterDecals event with a lambda handler function and keeping connection ID
endwaterdecals_handler_id = viewport->getEventEndWaterDecals().connect([]() { 
		Log::message("\Handling EndWaterDecals event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndWaterDecals().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndWaterDecals().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginWaterDecals().connect(beginwaterdecals_event_connections, beginwaterdecals_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginWaterDecals event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginWaterDecals event with a handler function
viewport->getEventBeginWaterDecals().connect(beginwaterdecals_event_handler);


// remove subscription for the BeginWaterDecals event later by the handler function
viewport->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 for the BeginWaterDecals event with a lambda handler function and keeping connection ID
beginwaterdecals_handler_id = viewport->getEventBeginWaterDecals().connect([]() { 
		Log::message("\Handling BeginWaterDecals event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginWaterDecals().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginWaterDecals().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginWater().connect(beginwater_event_connections, beginwater_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginWater event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginWater event with a handler function
viewport->getEventBeginWater().connect(beginwater_event_handler);


// remove subscription for the BeginWater event later by the handler function
viewport->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 for the BeginWater event with a lambda handler function and keeping connection ID
beginwater_handler_id = viewport->getEventBeginWater().connect([]() { 
		Log::message("\Handling BeginWater event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginWater().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginWater().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndClouds().connect(endclouds_event_connections, endclouds_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndClouds event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndClouds event with a handler function
viewport->getEventEndClouds().connect(endclouds_event_handler);


// remove subscription for the EndClouds event later by the handler function
viewport->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 for the EndClouds event with a lambda handler function and keeping connection ID
endclouds_handler_id = viewport->getEventEndClouds().connect([]() { 
		Log::message("\Handling EndClouds event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndClouds().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndClouds().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginClouds().connect(beginclouds_event_connections, beginclouds_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginClouds event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginClouds event with a handler function
viewport->getEventBeginClouds().connect(beginclouds_event_handler);


// remove subscription for the BeginClouds event later by the handler function
viewport->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 for the BeginClouds event with a lambda handler function and keeping connection ID
beginclouds_handler_id = viewport->getEventBeginClouds().connect([]() { 
		Log::message("\Handling BeginClouds event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginClouds().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginClouds().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginTransparent().connect(begintransparent_event_connections, begintransparent_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginTransparent event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginTransparent event with a handler function
viewport->getEventBeginTransparent().connect(begintransparent_event_handler);


// remove subscription for the BeginTransparent event later by the handler function
viewport->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 for the BeginTransparent event with a lambda handler function and keeping connection ID
begintransparent_handler_id = viewport->getEventBeginTransparent().connect([]() { 
		Log::message("\Handling BeginTransparent event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginTransparent().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginTransparent().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndCompositeDeferred().connect(endcompositedeferred_event_connections, endcompositedeferred_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndCompositeDeferred event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndCompositeDeferred event with a handler function
viewport->getEventEndCompositeDeferred().connect(endcompositedeferred_event_handler);


// remove subscription for the EndCompositeDeferred event later by the handler function
viewport->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 for the EndCompositeDeferred event with a lambda handler function and keeping connection ID
endcompositedeferred_handler_id = viewport->getEventEndCompositeDeferred().connect([]() { 
		Log::message("\Handling EndCompositeDeferred event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndCompositeDeferred().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndCompositeDeferred().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginCompositeDeferred().connect(begincompositedeferred_event_connections, begincompositedeferred_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginCompositeDeferred event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginCompositeDeferred event with a handler function
viewport->getEventBeginCompositeDeferred().connect(begincompositedeferred_event_handler);


// remove subscription for the BeginCompositeDeferred event later by the handler function
viewport->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 for the BeginCompositeDeferred event with a lambda handler function and keeping connection ID
begincompositedeferred_handler_id = viewport->getEventBeginCompositeDeferred().connect([]() { 
		Log::message("\Handling BeginCompositeDeferred event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginCompositeDeferred().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginCompositeDeferred().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndSky().connect(endsky_event_connections, endsky_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndSky event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndSky event with a handler function
viewport->getEventEndSky().connect(endsky_event_handler);


// remove subscription for the EndSky event later by the handler function
viewport->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 for the EndSky event with a lambda handler function and keeping connection ID
endsky_handler_id = viewport->getEventEndSky().connect([]() { 
		Log::message("\Handling EndSky event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndSky().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndSky().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginSky().connect(beginsky_event_connections, beginsky_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginSky event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginSky event with a handler function
viewport->getEventBeginSky().connect(beginsky_event_handler);


// remove subscription for the BeginSky event later by the handler function
viewport->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 for the BeginSky event with a lambda handler function and keeping connection ID
beginsky_handler_id = viewport->getEventBeginSky().connect([]() { 
		Log::message("\Handling BeginSky event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginSky().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginSky().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndSSGI().connect(endssgi_event_connections, endssgi_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndSSGI event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndSSGI event with a handler function
viewport->getEventEndSSGI().connect(endssgi_event_handler);


// remove subscription for the EndSSGI event later by the handler function
viewport->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 for the EndSSGI event with a lambda handler function and keeping connection ID
endssgi_handler_id = viewport->getEventEndSSGI().connect([]() { 
		Log::message("\Handling EndSSGI event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndSSGI().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndSSGI().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginSSGI().connect(beginssgi_event_connections, beginssgi_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginSSGI event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginSSGI event with a handler function
viewport->getEventBeginSSGI().connect(beginssgi_event_handler);


// remove subscription for the BeginSSGI event later by the handler function
viewport->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 for the BeginSSGI event with a lambda handler function and keeping connection ID
beginssgi_handler_id = viewport->getEventBeginSSGI().connect([]() { 
		Log::message("\Handling BeginSSGI event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginSSGI().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginSSGI().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndSSAO().connect(endssao_event_connections, endssao_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndSSAO event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndSSAO event with a handler function
viewport->getEventEndSSAO().connect(endssao_event_handler);


// remove subscription for the EndSSAO event later by the handler function
viewport->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 for the EndSSAO event with a lambda handler function and keeping connection ID
endssao_handler_id = viewport->getEventEndSSAO().connect([]() { 
		Log::message("\Handling EndSSAO event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndSSAO().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndSSAO().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginSSAO().connect(beginssao_event_connections, beginssao_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginSSAO event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginSSAO event with a handler function
viewport->getEventBeginSSAO().connect(beginssao_event_handler);


// remove subscription for the BeginSSAO event later by the handler function
viewport->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 for the BeginSSAO event with a lambda handler function and keeping connection ID
beginssao_handler_id = viewport->getEventBeginSSAO().connect([]() { 
		Log::message("\Handling BeginSSAO event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginSSAO().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginSSAO().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndSSR().connect(endssr_event_connections, endssr_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndSSR event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndSSR event with a handler function
viewport->getEventEndSSR().connect(endssr_event_handler);


// remove subscription for the EndSSR event later by the handler function
viewport->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 for the EndSSR event with a lambda handler function and keeping connection ID
endssr_handler_id = viewport->getEventEndSSR().connect([]() { 
		Log::message("\Handling EndSSR event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndSSR().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndSSR().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginSSR().connect(beginssr_event_connections, beginssr_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginSSR event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginSSR event with a handler function
viewport->getEventBeginSSR().connect(beginssr_event_handler);


// remove subscription for the BeginSSR event later by the handler function
viewport->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 for the BeginSSR event with a lambda handler function and keeping connection ID
beginssr_handler_id = viewport->getEventBeginSSR().connect([]() { 
		Log::message("\Handling BeginSSR event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginSSR().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginSSR().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndSSSS().connect(endssss_event_connections, endssss_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndSSSS event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndSSSS event with a handler function
viewport->getEventEndSSSS().connect(endssss_event_handler);


// remove subscription for the EndSSSS event later by the handler function
viewport->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 for the EndSSSS event with a lambda handler function and keeping connection ID
endssss_handler_id = viewport->getEventEndSSSS().connect([]() { 
		Log::message("\Handling EndSSSS event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndSSSS().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndSSSS().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginSSSS().connect(beginssss_event_connections, beginssss_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginSSSS event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginSSSS event with a handler function
viewport->getEventBeginSSSS().connect(beginssss_event_handler);


// remove subscription for the BeginSSSS event later by the handler function
viewport->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 for the BeginSSSS event with a lambda handler function and keeping connection ID
beginssss_handler_id = viewport->getEventBeginSSSS().connect([]() { 
		Log::message("\Handling BeginSSSS event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginSSSS().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginSSSS().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndTransparentBlurBuffer().connect(endtransparentblurbuffer_event_connections, endtransparentblurbuffer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndTransparentBlurBuffer event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndTransparentBlurBuffer event with a handler function
viewport->getEventEndTransparentBlurBuffer().connect(endtransparentblurbuffer_event_handler);


// remove subscription for the EndTransparentBlurBuffer event later by the handler function
viewport->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 for the EndTransparentBlurBuffer event with a lambda handler function and keeping connection ID
endtransparentblurbuffer_handler_id = viewport->getEventEndTransparentBlurBuffer().connect([]() { 
		Log::message("\Handling EndTransparentBlurBuffer event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndTransparentBlurBuffer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndTransparentBlurBuffer().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginTransparentBlurBuffer().connect(begintransparentblurbuffer_event_connections, begintransparentblurbuffer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginTransparentBlurBuffer event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginTransparentBlurBuffer event with a handler function
viewport->getEventBeginTransparentBlurBuffer().connect(begintransparentblurbuffer_event_handler);


// remove subscription for the BeginTransparentBlurBuffer event later by the handler function
viewport->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 for the BeginTransparentBlurBuffer event with a lambda handler function and keeping connection ID
begintransparentblurbuffer_handler_id = viewport->getEventBeginTransparentBlurBuffer().connect([]() { 
		Log::message("\Handling BeginTransparentBlurBuffer event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginTransparentBlurBuffer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginTransparentBlurBuffer().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndRefractionBuffer().connect(endrefractionbuffer_event_connections, endrefractionbuffer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndRefractionBuffer event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndRefractionBuffer event with a handler function
viewport->getEventEndRefractionBuffer().connect(endrefractionbuffer_event_handler);


// remove subscription for the EndRefractionBuffer event later by the handler function
viewport->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 for the EndRefractionBuffer event with a lambda handler function and keeping connection ID
endrefractionbuffer_handler_id = viewport->getEventEndRefractionBuffer().connect([]() { 
		Log::message("\Handling EndRefractionBuffer event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndRefractionBuffer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndRefractionBuffer().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginRefractionBuffer().connect(beginrefractionbuffer_event_connections, beginrefractionbuffer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginRefractionBuffer event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginRefractionBuffer event with a handler function
viewport->getEventBeginRefractionBuffer().connect(beginrefractionbuffer_event_handler);


// remove subscription for the BeginRefractionBuffer event later by the handler function
viewport->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 for the BeginRefractionBuffer event with a lambda handler function and keeping connection ID
beginrefractionbuffer_handler_id = viewport->getEventBeginRefractionBuffer().connect([]() { 
		Log::message("\Handling BeginRefractionBuffer event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginRefractionBuffer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginRefractionBuffer().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndAuxiliaryBuffer().connect(endauxiliarybuffer_event_connections, endauxiliarybuffer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndAuxiliaryBuffer event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndAuxiliaryBuffer event with a handler function
viewport->getEventEndAuxiliaryBuffer().connect(endauxiliarybuffer_event_handler);


// remove subscription for the EndAuxiliaryBuffer event later by the handler function
viewport->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 for the EndAuxiliaryBuffer event with a lambda handler function and keeping connection ID
endauxiliarybuffer_handler_id = viewport->getEventEndAuxiliaryBuffer().connect([]() { 
		Log::message("\Handling EndAuxiliaryBuffer event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndAuxiliaryBuffer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndAuxiliaryBuffer().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginAuxiliaryBuffer().connect(beginauxiliarybuffer_event_connections, beginauxiliarybuffer_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginAuxiliaryBuffer event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginAuxiliaryBuffer event with a handler function
viewport->getEventBeginAuxiliaryBuffer().connect(beginauxiliarybuffer_event_handler);


// remove subscription for the BeginAuxiliaryBuffer event later by the handler function
viewport->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 for the BeginAuxiliaryBuffer event with a lambda handler function and keeping connection ID
beginauxiliarybuffer_handler_id = viewport->getEventBeginAuxiliaryBuffer().connect([]() { 
		Log::message("\Handling BeginAuxiliaryBuffer event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginAuxiliaryBuffer().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginAuxiliaryBuffer().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndOpacityPlanarProbes().connect(endopacityplanarprobes_event_connections, endopacityplanarprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndOpacityPlanarProbes event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndOpacityPlanarProbes event with a handler function
viewport->getEventEndOpacityPlanarProbes().connect(endopacityplanarprobes_event_handler);


// remove subscription for the EndOpacityPlanarProbes event later by the handler function
viewport->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 for the EndOpacityPlanarProbes event with a lambda handler function and keeping connection ID
endopacityplanarprobes_handler_id = viewport->getEventEndOpacityPlanarProbes().connect([]() { 
		Log::message("\Handling EndOpacityPlanarProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndOpacityPlanarProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndOpacityPlanarProbes().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginOpacityPlanarProbes().connect(beginopacityplanarprobes_event_connections, beginopacityplanarprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginOpacityPlanarProbes event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginOpacityPlanarProbes event with a handler function
viewport->getEventBeginOpacityPlanarProbes().connect(beginopacityplanarprobes_event_handler);


// remove subscription for the BeginOpacityPlanarProbes event later by the handler function
viewport->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 for the BeginOpacityPlanarProbes event with a lambda handler function and keeping connection ID
beginopacityplanarprobes_handler_id = viewport->getEventBeginOpacityPlanarProbes().connect([]() { 
		Log::message("\Handling BeginOpacityPlanarProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginOpacityPlanarProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginOpacityPlanarProbes().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndOpacityEnvironmentProbes().connect(endopacityenvironmentprobes_event_connections, endopacityenvironmentprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndOpacityEnvironmentProbes event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndOpacityEnvironmentProbes event with a handler function
viewport->getEventEndOpacityEnvironmentProbes().connect(endopacityenvironmentprobes_event_handler);


// remove subscription for the EndOpacityEnvironmentProbes event later by the handler function
viewport->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 for the EndOpacityEnvironmentProbes event with a lambda handler function and keeping connection ID
endopacityenvironmentprobes_handler_id = viewport->getEventEndOpacityEnvironmentProbes().connect([]() { 
		Log::message("\Handling EndOpacityEnvironmentProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndOpacityEnvironmentProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndOpacityEnvironmentProbes().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginOpacityEnvironmentProbes().connect(beginopacityenvironmentprobes_event_connections, beginopacityenvironmentprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginOpacityEnvironmentProbes event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginOpacityEnvironmentProbes event with a handler function
viewport->getEventBeginOpacityEnvironmentProbes().connect(beginopacityenvironmentprobes_event_handler);


// remove subscription for the BeginOpacityEnvironmentProbes event later by the handler function
viewport->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 for the BeginOpacityEnvironmentProbes event with a lambda handler function and keeping connection ID
beginopacityenvironmentprobes_handler_id = viewport->getEventBeginOpacityEnvironmentProbes().connect([]() { 
		Log::message("\Handling BeginOpacityEnvironmentProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginOpacityEnvironmentProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginOpacityEnvironmentProbes().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndOpacityVoxelProbes().connect(endopacityvoxelprobes_event_connections, endopacityvoxelprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndOpacityVoxelProbes event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndOpacityVoxelProbes event with a handler function
viewport->getEventEndOpacityVoxelProbes().connect(endopacityvoxelprobes_event_handler);


// remove subscription for the EndOpacityVoxelProbes event later by the handler function
viewport->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 for the EndOpacityVoxelProbes event with a lambda handler function and keeping connection ID
endopacityvoxelprobes_handler_id = viewport->getEventEndOpacityVoxelProbes().connect([]() { 
		Log::message("\Handling EndOpacityVoxelProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndOpacityVoxelProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndOpacityVoxelProbes().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginOpacityVoxelProbes().connect(beginopacityvoxelprobes_event_connections, beginopacityvoxelprobes_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginOpacityVoxelProbes event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginOpacityVoxelProbes event with a handler function
viewport->getEventBeginOpacityVoxelProbes().connect(beginopacityvoxelprobes_event_handler);


// remove subscription for the BeginOpacityVoxelProbes event later by the handler function
viewport->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 for the BeginOpacityVoxelProbes event with a lambda handler function and keeping connection ID
beginopacityvoxelprobes_handler_id = viewport->getEventBeginOpacityVoxelProbes().connect([]() { 
		Log::message("\Handling BeginOpacityVoxelProbes event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginOpacityVoxelProbes().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginOpacityVoxelProbes().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndOpacityLights().connect(endopacitylights_event_connections, endopacitylights_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndOpacityLights event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndOpacityLights event with a handler function
viewport->getEventEndOpacityLights().connect(endopacitylights_event_handler);


// remove subscription for the EndOpacityLights event later by the handler function
viewport->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 for the EndOpacityLights event with a lambda handler function and keeping connection ID
endopacitylights_handler_id = viewport->getEventEndOpacityLights().connect([]() { 
		Log::message("\Handling EndOpacityLights event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndOpacityLights().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndOpacityLights().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginOpacityLights().connect(beginopacitylights_event_connections, beginopacitylights_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginOpacityLights event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginOpacityLights event with a handler function
viewport->getEventBeginOpacityLights().connect(beginopacitylights_event_handler);


// remove subscription for the BeginOpacityLights event later by the handler function
viewport->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 for the BeginOpacityLights event with a lambda handler function and keeping connection ID
beginopacitylights_handler_id = viewport->getEventBeginOpacityLights().connect([]() { 
		Log::message("\Handling BeginOpacityLights event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginOpacityLights().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginOpacityLights().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndSSRTGI().connect(endssrtgi_event_connections, endssrtgi_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndSSRTGI event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the EndSSRTGI event with a handler function
viewport->getEventEndSSRTGI().connect(endssrtgi_event_handler);


// remove subscription for the EndSSRTGI event later by the handler function
viewport->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 for the EndSSRTGI event with a lambda handler function and keeping connection ID
endssrtgi_handler_id = viewport->getEventEndSSRTGI().connect([]() { 
		Log::message("\Handling EndSSRTGI event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventEndSSRTGI().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndSSRTGI().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventBeginSSRTGI().connect(beginssrtgi_event_connections, beginssrtgi_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the BeginSSRTGI event with a handler function keeping the connection
viewport->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 for 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
viewport->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 for the BeginSSRTGI event with a handler function
viewport->getEventBeginSSRTGI().connect(beginssrtgi_event_handler);


// remove subscription for the BeginSSRTGI event later by the handler function
viewport->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 for the BeginSSRTGI event with a lambda handler function and keeping connection ID
beginssrtgi_handler_id = viewport->getEventBeginSSRTGI().connect([]() { 
		Log::message("\Handling BeginSSRTGI event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->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
viewport->getEventBeginSSRTGI().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginSSRTGI().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

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).

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 for an event (subscription for various events can be linked)
viewport->getEventEndCurvatureComposite().connect(endcurvaturecomposite_event_connections, endcurvaturecomposite_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
viewport->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 for the EndCurvatureComposite event with a handler function keeping the connection
viewport->getEventEndCurvatureComposite().connect(endcurvaturecomposite_event_connection, endcurvaturecomposite_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventEndCurvatureComposite().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 for the EndCurvatureComposite event with a handler function
viewport->getEventEndCurvatureComposite().connect(endcurvaturecomposite_event_handler);


// remove subscription for the EndCurvatureComposite event later by the handler function
viewport->getEventEndCurvatureComposite().disconnect(endcurvaturecomposite_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 endcurvaturecomposite_handler_id;

// subscribe for the EndCurvatureComposite event with a lambda handler function and keeping connection ID
endcurvaturecomposite_handler_id = viewport->getEventEndCurvatureComposite().connect([]() { 
		Log::message("\Handling EndCurvatureComposite event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventEndCurvatureComposite().disconnect(endcurvaturecomposite_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndCurvatureComposite().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventBeginCurvatureComposite() const#

event triggered before 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).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventBeginCurvatureComposite().connect(begincurvaturecomposite_event_connections, begincurvaturecomposite_event_handler);

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

// ...

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

// subscribe for the BeginCurvatureComposite event with a handler function keeping the connection
viewport->getEventBeginCurvatureComposite().connect(begincurvaturecomposite_event_connection, begincurvaturecomposite_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventBeginCurvatureComposite().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 for the BeginCurvatureComposite event with a handler function
viewport->getEventBeginCurvatureComposite().connect(begincurvaturecomposite_event_handler);


// remove subscription for the BeginCurvatureComposite event later by the handler function
viewport->getEventBeginCurvatureComposite().disconnect(begincurvaturecomposite_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 begincurvaturecomposite_handler_id;

// subscribe for the BeginCurvatureComposite event with a lambda handler function and keeping connection ID
begincurvaturecomposite_handler_id = viewport->getEventBeginCurvatureComposite().connect([]() { 
		Log::message("\Handling BeginCurvatureComposite event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventBeginCurvatureComposite().disconnect(begincurvaturecomposite_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginCurvatureComposite().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventEndCurvature() const#

event triggered after the SSBevel effect 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).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventEndCurvature().connect(endcurvature_event_connections, endcurvature_event_handler);

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

// ...

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

// subscribe for the EndCurvature event with a handler function keeping the connection
viewport->getEventEndCurvature().connect(endcurvature_event_connection, endcurvature_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventEndCurvature().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 for the EndCurvature event with a handler function
viewport->getEventEndCurvature().connect(endcurvature_event_handler);


// remove subscription for the EndCurvature event later by the handler function
viewport->getEventEndCurvature().disconnect(endcurvature_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 endcurvature_handler_id;

// subscribe for the EndCurvature event with a lambda handler function and keeping connection ID
endcurvature_handler_id = viewport->getEventEndCurvature().connect([]() { 
		Log::message("\Handling EndCurvature event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventEndCurvature().disconnect(endcurvature_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndCurvature().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventBeginCurvature() const#

event triggered before the SSBevel effect 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).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventBeginCurvature().connect(begincurvature_event_connections, begincurvature_event_handler);

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

// ...

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

// subscribe for the BeginCurvature event with a handler function keeping the connection
viewport->getEventBeginCurvature().connect(begincurvature_event_connection, begincurvature_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventBeginCurvature().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 for the BeginCurvature event with a handler function
viewport->getEventBeginCurvature().connect(begincurvature_event_handler);


// remove subscription for the BeginCurvature event later by the handler function
viewport->getEventBeginCurvature().disconnect(begincurvature_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 begincurvature_handler_id;

// subscribe for the BeginCurvature event with a lambda handler function and keeping connection ID
begincurvature_handler_id = viewport->getEventBeginCurvature().connect([]() { 
		Log::message("\Handling BeginCurvature event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventBeginCurvature().disconnect(begincurvature_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginCurvature().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventEndOpacityDecals() const#

event triggered after the opacity 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).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventEndOpacityDecals().connect(endopacitydecals_event_connections, endopacitydecals_event_handler);

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

// ...

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

// subscribe for the EndOpacityDecals event with a handler function keeping the connection
viewport->getEventEndOpacityDecals().connect(endopacitydecals_event_connection, endopacitydecals_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventEndOpacityDecals().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 for the EndOpacityDecals event with a handler function
viewport->getEventEndOpacityDecals().connect(endopacitydecals_event_handler);


// remove subscription for the EndOpacityDecals event later by the handler function
viewport->getEventEndOpacityDecals().disconnect(endopacitydecals_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 endopacitydecals_handler_id;

// subscribe for the EndOpacityDecals event with a lambda handler function and keeping connection ID
endopacitydecals_handler_id = viewport->getEventEndOpacityDecals().connect([]() { 
		Log::message("\Handling EndOpacityDecals event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventEndOpacityDecals().disconnect(endopacitydecals_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndOpacityDecals().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventBeginOpacityDecals() const#

event triggered before the opacity 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).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventBeginOpacityDecals().connect(beginopacitydecals_event_connections, beginopacitydecals_event_handler);

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

// ...

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

// subscribe for the BeginOpacityDecals event with a handler function keeping the connection
viewport->getEventBeginOpacityDecals().connect(beginopacitydecals_event_connection, beginopacitydecals_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventBeginOpacityDecals().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 for the BeginOpacityDecals event with a handler function
viewport->getEventBeginOpacityDecals().connect(beginopacitydecals_event_handler);


// remove subscription for the BeginOpacityDecals event later by the handler function
viewport->getEventBeginOpacityDecals().disconnect(beginopacitydecals_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 beginopacitydecals_handler_id;

// subscribe for the BeginOpacityDecals event with a lambda handler function and keeping connection ID
beginopacitydecals_handler_id = viewport->getEventBeginOpacityDecals().connect([]() { 
		Log::message("\Handling BeginOpacityDecals event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventBeginOpacityDecals().disconnect(beginopacitydecals_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginOpacityDecals().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventEndOpacityGBuffer() const#

event triggered after filling the Gbuffer. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventEndOpacityGBuffer().connect(endopacitygbuffer_event_connections, endopacitygbuffer_event_handler);

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

// ...

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

// subscribe for the EndOpacityGBuffer event with a handler function keeping the connection
viewport->getEventEndOpacityGBuffer().connect(endopacitygbuffer_event_connection, endopacitygbuffer_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventEndOpacityGBuffer().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 for the EndOpacityGBuffer event with a handler function
viewport->getEventEndOpacityGBuffer().connect(endopacitygbuffer_event_handler);


// remove subscription for the EndOpacityGBuffer event later by the handler function
viewport->getEventEndOpacityGBuffer().disconnect(endopacitygbuffer_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 endopacitygbuffer_handler_id;

// subscribe for the EndOpacityGBuffer event with a lambda handler function and keeping connection ID
endopacitygbuffer_handler_id = viewport->getEventEndOpacityGBuffer().connect([]() { 
		Log::message("\Handling EndOpacityGBuffer event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventEndOpacityGBuffer().disconnect(endopacitygbuffer_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndOpacityGBuffer().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventBeginOpacityGBuffer() const#

event triggered before filling the Gbuffer. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventBeginOpacityGBuffer().connect(beginopacitygbuffer_event_connections, beginopacitygbuffer_event_handler);

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

// ...

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

// subscribe for the BeginOpacityGBuffer event with a handler function keeping the connection
viewport->getEventBeginOpacityGBuffer().connect(beginopacitygbuffer_event_connection, beginopacitygbuffer_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventBeginOpacityGBuffer().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 for the BeginOpacityGBuffer event with a handler function
viewport->getEventBeginOpacityGBuffer().connect(beginopacitygbuffer_event_handler);


// remove subscription for the BeginOpacityGBuffer event later by the handler function
viewport->getEventBeginOpacityGBuffer().disconnect(beginopacitygbuffer_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 beginopacitygbuffer_handler_id;

// subscribe for the BeginOpacityGBuffer event with a lambda handler function and keeping connection ID
beginopacitygbuffer_handler_id = viewport->getEventBeginOpacityGBuffer().connect([]() { 
		Log::message("\Handling BeginOpacityGBuffer event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventBeginOpacityGBuffer().disconnect(beginopacitygbuffer_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginOpacityGBuffer().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventEndMixedRealityBlendMaskColor() const#

event triggered after the mask for Mixed Reality is rendered (after Common Camera for clouds and before Opacity GBuffer). You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventEndMixedRealityBlendMaskColor().connect(endmixedrealityblendmaskcolor_event_connections, endmixedrealityblendmaskcolor_event_handler);

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

// ...

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

// subscribe for the EndMixedRealityBlendMaskColor event with a handler function keeping the connection
viewport->getEventEndMixedRealityBlendMaskColor().connect(endmixedrealityblendmaskcolor_event_connection, endmixedrealityblendmaskcolor_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventEndMixedRealityBlendMaskColor().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 for the EndMixedRealityBlendMaskColor event with a handler function
viewport->getEventEndMixedRealityBlendMaskColor().connect(endmixedrealityblendmaskcolor_event_handler);


// remove subscription for the EndMixedRealityBlendMaskColor event later by the handler function
viewport->getEventEndMixedRealityBlendMaskColor().disconnect(endmixedrealityblendmaskcolor_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 endmixedrealityblendmaskcolor_handler_id;

// subscribe for the EndMixedRealityBlendMaskColor event with a lambda handler function and keeping connection ID
endmixedrealityblendmaskcolor_handler_id = viewport->getEventEndMixedRealityBlendMaskColor().connect([]() { 
		Log::message("\Handling EndMixedRealityBlendMaskColor event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventEndMixedRealityBlendMaskColor().disconnect(endmixedrealityblendmaskcolor_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndMixedRealityBlendMaskColor().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventBeginMixedRealityBlendMaskColor() const#

event triggered before the mask for Mixed Reality is rendered (after Common Camera for clouds and before Opacity GBuffer). You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventBeginMixedRealityBlendMaskColor().connect(beginmixedrealityblendmaskcolor_event_connections, beginmixedrealityblendmaskcolor_event_handler);

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

// ...

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

// subscribe for the BeginMixedRealityBlendMaskColor event with a handler function keeping the connection
viewport->getEventBeginMixedRealityBlendMaskColor().connect(beginmixedrealityblendmaskcolor_event_connection, beginmixedrealityblendmaskcolor_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventBeginMixedRealityBlendMaskColor().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 for the BeginMixedRealityBlendMaskColor event with a handler function
viewport->getEventBeginMixedRealityBlendMaskColor().connect(beginmixedrealityblendmaskcolor_event_handler);


// remove subscription for the BeginMixedRealityBlendMaskColor event later by the handler function
viewport->getEventBeginMixedRealityBlendMaskColor().disconnect(beginmixedrealityblendmaskcolor_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 beginmixedrealityblendmaskcolor_handler_id;

// subscribe for the BeginMixedRealityBlendMaskColor event with a lambda handler function and keeping connection ID
beginmixedrealityblendmaskcolor_handler_id = viewport->getEventBeginMixedRealityBlendMaskColor().connect([]() { 
		Log::message("\Handling BeginMixedRealityBlendMaskColor event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventBeginMixedRealityBlendMaskColor().disconnect(beginmixedrealityblendmaskcolor_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginMixedRealityBlendMaskColor().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventBeginScreen() const#

event triggered before 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).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventBeginScreen().connect(beginscreen_event_connections, beginscreen_event_handler);

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

// ...

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

// subscribe for the BeginScreen event with a handler function keeping the connection
viewport->getEventBeginScreen().connect(beginscreen_event_connection, beginscreen_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventBeginScreen().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 for the BeginScreen event with a handler function
viewport->getEventBeginScreen().connect(beginscreen_event_handler);


// remove subscription for the BeginScreen event later by the handler function
viewport->getEventBeginScreen().disconnect(beginscreen_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 beginscreen_handler_id;

// subscribe for the BeginScreen event with a lambda handler function and keeping connection ID
beginscreen_handler_id = viewport->getEventBeginScreen().connect([]() { 
		Log::message("\Handling BeginScreen event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventBeginScreen().disconnect(beginscreen_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginScreen().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventEndShadows() const#

event triggered after the shadows 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).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventEndShadows().connect(endshadows_event_connections, endshadows_event_handler);

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

// ...

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

// subscribe for the EndShadows event with a handler function keeping the connection
viewport->getEventEndShadows().connect(endshadows_event_connection, endshadows_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventEndShadows().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 for the EndShadows event with a handler function
viewport->getEventEndShadows().connect(endshadows_event_handler);


// remove subscription for the EndShadows event later by the handler function
viewport->getEventEndShadows().disconnect(endshadows_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 endshadows_handler_id;

// subscribe for the EndShadows event with a lambda handler function and keeping connection ID
endshadows_handler_id = viewport->getEventEndShadows().connect([]() { 
		Log::message("\Handling EndShadows event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventEndShadows().disconnect(endshadows_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndShadows().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventEndOmniShadow() const#

event triggered after the stage of rendering shadows from Omni light sources. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventEndOmniShadow().connect(endomnishadow_event_connections, endomnishadow_event_handler);

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

// ...

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

// subscribe for the EndOmniShadow event with a handler function keeping the connection
viewport->getEventEndOmniShadow().connect(endomnishadow_event_connection, endomnishadow_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventEndOmniShadow().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 for the EndOmniShadow event with a handler function
viewport->getEventEndOmniShadow().connect(endomnishadow_event_handler);


// remove subscription for the EndOmniShadow event later by the handler function
viewport->getEventEndOmniShadow().disconnect(endomnishadow_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 endomnishadow_handler_id;

// subscribe for the EndOmniShadow event with a lambda handler function and keeping connection ID
endomnishadow_handler_id = viewport->getEventEndOmniShadow().connect([]() { 
		Log::message("\Handling EndOmniShadow event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventEndOmniShadow().disconnect(endomnishadow_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndOmniShadow().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventBeginOmniShadow() const#

event triggered before the stage of rendering shadows from Omni light sources. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventBeginOmniShadow().connect(beginomnishadow_event_connections, beginomnishadow_event_handler);

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

// ...

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

// subscribe for the BeginOmniShadow event with a handler function keeping the connection
viewport->getEventBeginOmniShadow().connect(beginomnishadow_event_connection, beginomnishadow_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventBeginOmniShadow().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 for the BeginOmniShadow event with a handler function
viewport->getEventBeginOmniShadow().connect(beginomnishadow_event_handler);


// remove subscription for the BeginOmniShadow event later by the handler function
viewport->getEventBeginOmniShadow().disconnect(beginomnishadow_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 beginomnishadow_handler_id;

// subscribe for the BeginOmniShadow event with a lambda handler function and keeping connection ID
beginomnishadow_handler_id = viewport->getEventBeginOmniShadow().connect([]() { 
		Log::message("\Handling BeginOmniShadow event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventBeginOmniShadow().disconnect(beginomnishadow_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginOmniShadow().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventEndProjShadow() const#

event triggered after the stage of rendering shadows from Projected light sources. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventEndProjShadow().connect(endprojshadow_event_connections, endprojshadow_event_handler);

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

// ...

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

// subscribe for the EndProjShadow event with a handler function keeping the connection
viewport->getEventEndProjShadow().connect(endprojshadow_event_connection, endprojshadow_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventEndProjShadow().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 for the EndProjShadow event with a handler function
viewport->getEventEndProjShadow().connect(endprojshadow_event_handler);


// remove subscription for the EndProjShadow event later by the handler function
viewport->getEventEndProjShadow().disconnect(endprojshadow_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 endprojshadow_handler_id;

// subscribe for the EndProjShadow event with a lambda handler function and keeping connection ID
endprojshadow_handler_id = viewport->getEventEndProjShadow().connect([]() { 
		Log::message("\Handling EndProjShadow event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventEndProjShadow().disconnect(endprojshadow_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndProjShadow().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventBeginProjShadow() const#

event triggered before the stage of rendering shadows from Projected light sources. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventBeginProjShadow().connect(beginprojshadow_event_connections, beginprojshadow_event_handler);

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

// ...

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

// subscribe for the BeginProjShadow event with a handler function keeping the connection
viewport->getEventBeginProjShadow().connect(beginprojshadow_event_connection, beginprojshadow_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventBeginProjShadow().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 for the BeginProjShadow event with a handler function
viewport->getEventBeginProjShadow().connect(beginprojshadow_event_handler);


// remove subscription for the BeginProjShadow event later by the handler function
viewport->getEventBeginProjShadow().disconnect(beginprojshadow_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 beginprojshadow_handler_id;

// subscribe for the BeginProjShadow event with a lambda handler function and keeping connection ID
beginprojshadow_handler_id = viewport->getEventBeginProjShadow().connect([]() { 
		Log::message("\Handling BeginProjShadow event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventBeginProjShadow().disconnect(beginprojshadow_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginProjShadow().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventEndWorldShadow() const#

event triggered after the stage of rendering shadows from World light sources. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventEndWorldShadow().connect(endworldshadow_event_connections, endworldshadow_event_handler);

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

// ...

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

// subscribe for the EndWorldShadow event with a handler function keeping the connection
viewport->getEventEndWorldShadow().connect(endworldshadow_event_connection, endworldshadow_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventEndWorldShadow().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 for the EndWorldShadow event with a handler function
viewport->getEventEndWorldShadow().connect(endworldshadow_event_handler);


// remove subscription for the EndWorldShadow event later by the handler function
viewport->getEventEndWorldShadow().disconnect(endworldshadow_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 endworldshadow_handler_id;

// subscribe for the EndWorldShadow event with a lambda handler function and keeping connection ID
endworldshadow_handler_id = viewport->getEventEndWorldShadow().connect([]() { 
		Log::message("\Handling EndWorldShadow event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventEndWorldShadow().disconnect(endworldshadow_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndWorldShadow().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventBeginWorldShadow() const#

event triggered before the stage of rendering shadows from World light sources. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventBeginWorldShadow().connect(beginworldshadow_event_connections, beginworldshadow_event_handler);

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

// ...

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

// subscribe for the BeginWorldShadow event with a handler function keeping the connection
viewport->getEventBeginWorldShadow().connect(beginworldshadow_event_connection, beginworldshadow_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventBeginWorldShadow().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 for the BeginWorldShadow event with a handler function
viewport->getEventBeginWorldShadow().connect(beginworldshadow_event_handler);


// remove subscription for the BeginWorldShadow event later by the handler function
viewport->getEventBeginWorldShadow().disconnect(beginworldshadow_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 beginworldshadow_handler_id;

// subscribe for the BeginWorldShadow event with a lambda handler function and keeping connection ID
beginworldshadow_handler_id = viewport->getEventBeginWorldShadow().connect([]() { 
		Log::message("\Handling BeginWorldShadow event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventBeginWorldShadow().disconnect(beginworldshadow_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginWorldShadow().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventBeginShadows() const#

event triggered before the shadows 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).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventBeginShadows().connect(beginshadows_event_connections, beginshadows_event_handler);

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

// ...

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

// subscribe for the BeginShadows event with a handler function keeping the connection
viewport->getEventBeginShadows().connect(beginshadows_event_connection, beginshadows_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventBeginShadows().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 for the BeginShadows event with a handler function
viewport->getEventBeginShadows().connect(beginshadows_event_handler);


// remove subscription for the BeginShadows event later by the handler function
viewport->getEventBeginShadows().disconnect(beginshadows_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 beginshadows_handler_id;

// subscribe for the BeginShadows event with a lambda handler function and keeping connection ID
beginshadows_handler_id = viewport->getEventBeginShadows().connect([]() { 
		Log::message("\Handling BeginShadows event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventBeginShadows().disconnect(beginshadows_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginShadows().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventEndEnvironment() const#

event triggered after the Environment 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).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventEndEnvironment().connect(endenvironment_event_connections, endenvironment_event_handler);

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

// ...

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

// subscribe for the EndEnvironment event with a handler function keeping the connection
viewport->getEventEndEnvironment().connect(endenvironment_event_connection, endenvironment_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventEndEnvironment().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 for the EndEnvironment event with a handler function
viewport->getEventEndEnvironment().connect(endenvironment_event_handler);


// remove subscription for the EndEnvironment event later by the handler function
viewport->getEventEndEnvironment().disconnect(endenvironment_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 endenvironment_handler_id;

// subscribe for the EndEnvironment event with a lambda handler function and keeping connection ID
endenvironment_handler_id = viewport->getEventEndEnvironment().connect([]() { 
		Log::message("\Handling EndEnvironment event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventEndEnvironment().disconnect(endenvironment_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventEndEnvironment().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventBeginEnvironment() const#

event triggered before the Environment 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).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventBeginEnvironment().connect(beginenvironment_event_connections, beginenvironment_event_handler);

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

// ...

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

// subscribe for the BeginEnvironment event with a handler function keeping the connection
viewport->getEventBeginEnvironment().connect(beginenvironment_event_connection, beginenvironment_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventBeginEnvironment().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 for the BeginEnvironment event with a handler function
viewport->getEventBeginEnvironment().connect(beginenvironment_event_handler);


// remove subscription for the BeginEnvironment event later by the handler function
viewport->getEventBeginEnvironment().disconnect(beginenvironment_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 beginenvironment_handler_id;

// subscribe for the BeginEnvironment event with a lambda handler function and keeping connection ID
beginenvironment_handler_id = viewport->getEventBeginEnvironment().connect([]() { 
		Log::message("\Handling BeginEnvironment event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventBeginEnvironment().disconnect(beginenvironment_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBeginEnvironment().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event<> getEventBegin() const#

event triggered when rendering of the frame begins. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

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

// link to this instance when subscribing for an event (subscription for various events can be linked)
viewport->getEventBegin().connect(begin_event_connections, begin_event_handler);

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

// ...

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

// subscribe for the Begin event with a handler function keeping the connection
viewport->getEventBegin().connect(begin_event_connection, begin_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
viewport->getEventBegin().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 for the Begin event with a handler function
viewport->getEventBegin().connect(begin_event_handler);


// remove subscription for the Begin event later by the handler function
viewport->getEventBegin().disconnect(begin_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 begin_handler_id;

// subscribe for the Begin event with a lambda handler function and keeping connection ID
begin_handler_id = viewport->getEventBegin().connect([]() { 
		Log::message("\Handling Begin event (lambda).\n");
	}
);

// remove the subscription later using the ID
viewport->getEventBegin().disconnect(begin_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
viewport->getEventBegin().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

static ViewportPtr create ( ) #

Creates a new viewport with default settings.

void setAspectCorrection ( bool correction ) #

Sets the aspect correction for current viewport. true enables correction, false disables it.

Arguments

  • bool correction - true to enable aspect correction, false to disable.

bool isAspectCorrection ( ) const#

Return the value indicating if the aspect correction enabled for the current viewport.

Return value

true if the aspect correction enabled, otherwise false.

void setFirstFrame ( int frame ) #

Sets a value indicating if the first frame should be enabled over the current frame.

Arguments

  • int frame - 1 to set the first frame flag; otherwise, 0.

int getFirstFrame ( ) const#

Returns a value indicating if the first frame is enabled over the current frame.

Return value

1 if the first frame flag is set; otherwise, 0.

int getID ( ) const#

Returns the viewport ID.

Return value

Viewport ID.

void setMode ( Render::VIEWPORT_MODE mode ) #

Sets the rendering mode for the current viewport. It can be one of the stereo or panoramic modes or the default mode.

Arguments

Render::VIEWPORT_MODE getMode ( ) const#

Returns the rendering mode set for the current viewport. It can be one of the stereo or panoramic modes or the default mode.

Return value

The current rendering mode.

int getNodeLightUsage ( ) const#

Returns the type of lighting of the render node.

Return value

The lighting type. Can be one of the following:

bool isPanorama ( ) const#

Returns a value indicating if the panoramic rendering is enabled.

Return value

true if the panoramic rendering is enabled; otherwise, false.

void setPanoramaFisheyeFov ( float fov ) #

Sets a new Field of View angle to be used for the panorama rendering mode.

Arguments

  • float fov - New Field of View angle to be set for the panorama rendering mode, in degrees

float getPanoramaFisheyeFov ( ) const#

Returns the current Field of View angle used for the panorama rendering mode.

Return value

Current Field of View angle for the panorama rendering mode, in degrees

void setRenderMode ( int mode ) #

Sets the specified render mode. The mode determines the set of buffers to be rendered.

Arguments

int getRenderMode ( ) const#

Returns the current render mode. The mode determines the set of buffers to be rendered.

Return value

Current render mode. Can be one of the following:

void setSkipFlags ( int flags ) #

Sets the skip flag for the current viewport.

Arguments

int getSkipFlags ( ) const#

Returns the skip flag set for the current viewport.

Return value

A skip flag.

bool isStereo ( ) const#

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

Return value

true if the stereo rendering is enabled; otherwise, false.

void setStereoDistance ( float distance ) #

Sets the focal distance for stereo rendering (distance in the world space to the point where two views line up, i.e. to the zero parallax plane).

Arguments

  • float distance - A focal distance in units.

float getStereoDistance ( ) const#

Returns the focal distance for stereo rendering (distance in the world space to the point where two views line up, i.e. to the zero parallax plane).

Return value

A focal distance in units.

void setStereoOffset ( float offset ) #

Updates the virtual camera offset (an offset after the perspective projection).

Arguments

  • float offset - A virtual camera offset in units.

float getStereoOffset ( ) const#

Returns the virtual camera offset (an offset after the perspective projection).

Return value

A virtual camera offset in units.

void setStereoRadius ( float radius ) #

Updates the radius for stereo - the half of the separation distance between the cameras (i.e. between eyes).

Arguments

  • float radius - A stereo radius in units. If a negative value is provided, 0 will be used instead.

float getStereoRadius ( ) const#

Returns the current radius for stereo - the half of the separation distance between the cameras (i.e. between eyes).

Return value

Stereo radius in units.

void appendSkipFlags ( int flags ) #

Appends specified skip flags to the list of currently used ones.

Arguments

int checkSkipFlags ( int flags ) #

Returns a value indicating if the specified skip flags are set for the current viewport.

Arguments

Return value

1 if the skip flags are set; otherwise, 0.

void removeSkipFlags ( int flags ) #

Removes specified skip flags from the list of currently used ones.

Arguments

void render ( const Ptr<Camera> & camera ) #

Renders an image from the specified camera. This method is used to integrate the engine to a 3rd party renderer.

To render an image from the camera to the RenderTarget interface, do the following:

Source code (C++)
camera = Camera::create();

render_target->enable();
{
	viewport->render(camera);
}
render_target->disable();

Arguments

  • const Ptr<Camera> & camera - Camera an image from which should be rendered.

void render ( const Ptr<Camera> & camera, int width, int height ) #

Renders an image of the specified size from the specified camera to the current rendering target.

Arguments

  • const Ptr<Camera> & camera - Camera, an image from which should be rendered.
  • int width - Image width, in pixels.
  • int height - Image height, in pixels.

void renderEngine ( const Ptr<Camera> & camera ) #

Renders an Engine viewport for the specified camera to the current rendering target. This method renders a splash screen and provides an image in accordance with panoramic and stereo rendering settings.

Arguments

  • const Ptr<Camera> & camera - Camera, an image from which should be rendered.

void renderTexture2D ( const Ptr<Camera> & camera, const Ptr<Texture> & texture ) #

Renders an image from the camera to the specified 2D texture.

Arguments

  • const Ptr<Camera> & camera - Camera, an image from which should be rendered.
  • const Ptr<Texture> & texture - Target 2D texture to save the result to.

void renderTexture2D ( const Ptr<Camera> & camera, const Ptr<Texture> & texture, int width, int height, bool hdr = 0 ) #

Renders an image of the specified size from the camera to a 2D texture.

Arguments

  • const Ptr<Camera> & camera - Camera, an image from which should be rendered.
  • const Ptr<Texture> & texture - Target 2D texture to save the result to.
  • int width - Texture width, in pixels.
  • int height - Texture height, in pixels.
  • bool hdr - HDR flag.
    Notice
    This parameter determines the format of the 2D texture:
    • 1 - texture format will be set to RGBA16F
    • 0 - texture format will be set to RGBA8

void renderTextureCube ( const Ptr<Camera> & camera, const Ptr<Texture> & texture, bool local_space = false ) #

Renders the image from the camera to the cubemap texture.

Arguments

  • const Ptr<Camera> & camera - Camera, an image from which should be rendered.
  • const Ptr<Texture> & texture - Target Cube texture to save the result to.
  • bool local_space - A flag indicating if the camera angle should be used for the cube map rendering.

void renderTextureCube ( const Ptr<Camera> & camera, const Ptr<Texture> & texture, int size, bool hdr = 0, bool local_space = 0 ) #

Renders the image from the camera to the cube map of the specified size.

Arguments

  • const Ptr<Camera> & camera - Camera, an image from which should be rendered.
  • const Ptr<Texture> & texture - Target cube map to save the result to.
  • int size - Cube map edge size.
  • bool hdr - HDR flag.
    Notice
    This parameter determines the format of the 2D texture:
    • 1 - texture format will be set to RGBA16F
    • 0 - texture format will be set to RGBA8
  • bool local_space - A flag indicating if the camera angle should be used for the cube map rendering.

void renderNode ( const Ptr<Camera> & camera, const Ptr<Node> & node ) #

Renders the given node with all children to the current rendering target.

Arguments

  • const Ptr<Camera> & camera - Camera, an image from which should be rendered.
  • const Ptr<Node> & node - Node to be rendered.

void renderNode ( const Ptr<Camera> & camera, const Ptr<Node> & node, int width, int height ) #

Renders the given node with all children to the current rendering target.

Arguments

  • const Ptr<Camera> & camera - Camera, an image from which should be rendered.
  • const Ptr<Node> & node - Node to be rendered.
  • int width - Image width, in pixels.
  • int height - Image height, in pixels.

void renderNodeTexture2D ( const Ptr<Camera> & camera, const Ptr<Node> & node, const Ptr<Texture> & texture, int width, int height, bool hdr ) #

Renders the given node with all children to the 2D texture of the specified size.

Arguments

  • const Ptr<Camera> & camera - Camera, an image from which should be rendered.
  • const Ptr<Node> & node - Pointer to the node to be rendered.
  • const Ptr<Texture> & texture - Target 2D texture to save the result to.
  • int width - Texture width, in pixels.
  • int height - Texture height, in pixels.
  • bool hdr - HDR flag.
    Notice
    This parameter determines the format of the 2D texture:
    • 1 - texture format will be set to RGBA16F
    • 0 - texture format will be set to RGBA8

void renderNodeTexture2D ( const Ptr<Camera> & camera, const Ptr<Node> & node, const Ptr<Texture> & texture ) #

Renders the given node with all children to the specified 2D texture.

Arguments

  • const Ptr<Camera> & camera - Camera, an image from which should be rendered.
  • const Ptr<Node> & node - Pointer to the node to be rendered.
  • const Ptr<Texture> & texture - Target 2D texture to save the result to.

void renderNodes ( const Ptr<Camera> & camera, const Vector<Ptr<Node>> & nodes ) #

Renders given nodes with all their children to the current rendering target.

Arguments

  • const Ptr<Camera> & camera - Camera, an image from which should be rendered.
  • const Vector<Ptr<Node>> & nodes - List of the nodes to be rendered.

void renderNodes ( const Ptr<Camera> & camera, const Vector<Ptr<Node>> & nodes, int width, int height ) #

Renders given nodes with all their children to the current rendering target of the specified size.

Arguments

  • const Ptr<Camera> & camera - Camera, an image from which should be rendered.
  • const Vector<Ptr<Node>> & nodes - List of the nodes to be rendered.
  • int width - Image width, in pixels.
  • int height - Image height, in pixels.

void renderNodesTexture2D ( const Ptr<Camera> & camera, const Vector<Ptr<Node>> & nodes, const Ptr<Texture> & texture, int width, int height, int hdr ) #

Renders given nodes with all their children to the 2D texture of the specified size.

Arguments

  • const Ptr<Camera> & camera - Camera, an image from which should be rendered.
  • const Vector<Ptr<Node>> & nodes - List of the nodes to be rendered.
  • const Ptr<Texture> & texture - Target 2D texture to save the result to.
  • int width - Texture width, in pixels.
  • int height - Texture height, in pixels.
  • int hdr - HDR flag.
    Notice
    This parameter determines the format of the 2D image:
    • 1 - texture format will be set to RGBA16F
    • 0 - texture format will be set to RGBA8

void renderNodesTexture2D ( const Ptr<Camera> & camera, const Vector<Ptr<Node>> & nodes, const Ptr<Texture> & texture ) #

Renders given nodes with all their children to the specified 2D texture.

Arguments

  • const Ptr<Camera> & camera - Camera, an image from which should be rendered.
  • const Vector<Ptr<Node>> & nodes - List of the nodes to be rendered.
  • const Ptr<Texture> & texture - Target 2D texture to save the result to.

void renderStereo ( const Ptr<Camera> & camera_left, const Ptr<Camera> & camera_right, const char * stereo_material ) #

Renders a stereo image in the current viewport.

Arguments

  • const Ptr<Camera> & camera_left - Camera that renders an image for the left eye.
  • const Ptr<Camera> & camera_right - Camera that renders an image for the right eye.
  • const char * stereo_material - List of names of stereo materials to be used.

void renderStereoPeripheral ( const Ptr<Camera> & camera_left, const Ptr<Camera> & camera_right, const Ptr<Camera> & camera_focus_left, const Ptr<Camera> & camera_focus_right, const Ptr<Texture> & texture_left, const Ptr<Texture> & texture_right, const Ptr<Texture> & texture_focus_left, const Ptr<Texture> & texture_focus_right, const char * stereo_material ) #

Renders a stereo image for HMDs having context (peripheral) and focus displays. This method saves performance on shadows and reflections along with other optimizations reducing rendering load, such as reduced resolutions for textures.

Arguments

  • const Ptr<Camera> & camera_left - Camera that renders an image for the left context (low-res) display.
  • const Ptr<Camera> & camera_right - Camera that renders an image for the right context (low-res) display.
  • const Ptr<Camera> & camera_focus_left - Camera that renders an image for the left focus (high-res) display.
  • const Ptr<Camera> & camera_focus_right - Camera that renders an image for the right focus (high-res) display.
  • const Ptr<Texture> & texture_left - Texture to save the image rendered for the left context (low-res) display.
  • const Ptr<Texture> & texture_right - Texture to save the image rendered for the right context (low-res) display.
  • const Ptr<Texture> & texture_focus_left - Texture to save the image rendered for the left focus (high-res) display.
  • const Ptr<Texture> & texture_focus_right - Texture to save the image rendered for the right focus (high-res) display.
  • const char * stereo_material - List of names of stereo materials to be used.

void setStereoHiddenAreaMesh ( const Ptr<Mesh> & hidden_area_mesh_left, const Ptr<Mesh> & hidden_area_mesh_right ) #

Sets custom meshes to be used for culling pixels, that are not visible in VR.
Notice

Arguments

  • const Ptr<Mesh> & hidden_area_mesh_left - Mesh representing hidden area for the left eye.
  • const Ptr<Mesh> & hidden_area_mesh_right - Mesh representing hidden area for the right eye.

void clearStereoHiddenAreaMesh ( ) #

Clears meshes that represent hidden areas for both, left and right eye. Hidden areas are used for culling pixels, that are not visible in VR

void setEnvironmentTexturePath ( const char * name ) #

Sets the path to the cubemap defining the environment color for the viewport. This texture is used for imitating landscape reflections and lighting in accordance with the ground mask.

Arguments

  • const char * name - Path to the cubemap defining the environment color.

const char * getEnvironmentTexturePath ( ) #

Returns the path to the cubemap defining the environment color set for the viewport. This texture is used for imitating landscape reflections and lighting in accordance with the ground mask.

Return value

Path to the cubemap defining the environment color.

void setEnvironmentTexture ( const Ptr<Texture> & texture ) #

Sets the specified environment texture.

Arguments

  • const Ptr<Texture> & texture - Cubemap defining the environment color.

Ptr<Texture> getEnvironmentTexture ( ) const#

Returns the current environment texture.

Return value

Cubemap defining the environment color.

void resetEnvironmentTexture ( ) #

Resets the current environment texture to the default one.

void setPaused ( bool paused ) #

Sets the viewport rendering to the paused mode.

Arguments

  • bool paused - A flag indicating if the current viewport should be paused or not.

bool isPaused ( ) const#

Returns a value indicating if the rendering in the current viewport is paused or not.

Return value

1 if the viewport is paused; otherwise, 0.

void setNodeLightUsage ( int usage ) #

Sets the type of lighting for the render of a node (used for impostor grabbing, node preview rendering, etc.).

Arguments

  • int usage - The lighting type. Can be one of the following:
    • 0 - USAGE_WORLD_LIGHT (use lighting from the LightWorld set in the current loaded world).
    • 1 - USAGE_AUX_LIGHT (use lighting from the auxiliary virtual scene containing one LightWorld with 45 degrees slope angles along all axes, scattering is not used).
    • 2 - USAGE_NODE_LIGHT (use the node lighting).

void setUseTAAOffset ( bool offset ) #

Sets a value indicating if skipping render mode check is enabled for using TAA. Can be used to ensure proper TAA calculation when rendering mode for the Viewport is set to RENDER_DEPTH.

Arguments

  • bool offset - true to enable skipping render mode check and use TAA; otherwise false.

bool isUseTAAOffset ( ) const#

Returns a value indicating if skipping render mode check is enabled for using TAA. Can be used to ensure proper TAA calculation when rendering mode for the Viewport is set to RENDER_DEPTH.

Return value

true if skipping render mode check is enabled for using TAA; otherwise false.

void renderVREngine ( ) #

Renders the VR viewport if VR is enabled, taking into account the vr mirror mode set.
Last update: 2023-12-19
Build: ()