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:
-
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.
NoticeViewportQt sample is available only for the Engineering and Sim editions of UNIGINE SDKs.
-
-
Render a scene to a texture (data stays in the GPU memory).
-
To render the scene to a Texture interface, use the following methods:
- renderTexture2D(camera,texture)
- renderTexture2D(camera,texture,width,height,hdr)
- renderTextureCube(camera,texture,local_space)
- renderTextureCube(camera,texture,size,hdr,local_space)
Source code (C++)ViewportPtr viewport; TexturePtr texture; CameraPtr camera; int AppWorldLogic::init() { // initialization 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 // // saving current render state and clearing it RenderState::saveState(); RenderState::clearStates(); { viewport->renderTexture2D(camera, texture); } RenderState::restoreState(); return 1; }
-
-
Render a node to a texture (data stays in the GPU memory).
- To render a node (or nodes) to a Texture interface, use the following methods:
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#
-
See the following C++/C# samples:
- source/samples/Api/Render/GBufferWrite
- source/samples/Api/Render/GBufferRead
- Render to Texture sample in CPP Samples suite
- Weapon Clipping sample in C# Component Samples suite
-
See the following C++/C# usage example:
Viewport Class
Members
void setNodeLightUsage ( int usage ) #
Sets a new type of lighting of the render node.
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).
int getNodeLightUsage() const#
Returns the current type of lighting of the render node.
Return value
Current 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 setStereoOffset ( float offset ) #
Sets a new virtual camera offset (an offset after the perspective projection).
Arguments
- float offset - The virtual camera offset in units.
float getStereoOffset() const#
Returns the current virtual camera offset (an offset after the perspective projection).
Return value
Current virtual camera offset in units.void setStereoRadius ( float radius ) #
Sets a new radius for stereo — the half of the separation distance between the cameras (i.e. between eyes).
Arguments
- float radius - The 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
Current stereo radius in units. If a negative value is provided, 0 will be used instead.void setStereoDistance ( float distance ) #
Sets a new 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 - The focal distance in units.
float getStereoDistance() const#
Returns the current 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
Current focal distance in units.bool 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
true if stereo rendering for the current viewport (one of the stereo modes) is enabled; otherwise false.bool isPanorama() const#
Returns the current value indicating if the panoramic rendering is enabled.
Return value
true if panoramic rendering is enabled; otherwise false.void setRenderMode ( int mode ) #
Sets a new render mode. The mode determines the set of buffers to be rendered.
Arguments
- int mode - The render mode, one of the following:
int getRenderMode() const#
Returns the current render mode. The mode determines the set of buffers to be rendered.
Return value
Current render mode, one of the following:void setMode ( Render::VIEWPORT_MODE mode ) #
Sets a new rendering mode for the current viewport.
Arguments
- Render::VIEWPORT_MODE mode - The rendering mode set for the current viewport. It can be one of the stereo or panoramic modes or the default mode.
Render::VIEWPORT_MODE getMode() const#
Returns the current rendering mode for the current viewport.
Return value
Current rendering mode set for the current viewport. It can be one of the stereo or panoramic modes or the default mode.void setSkipFlags ( int flags ) #
Sets a new skip flag set for the current viewport.
Arguments
- int flags - The skip flag set for the current viewport.
int getSkipFlags() const#
Returns the current skip flag set for the current viewport.
Return value
Current skip flag set for the current viewport.void setFirstFrame ( int frame ) #
Sets a new value indicating if the first frame is enabled over the current frame.
Arguments
- int frame - The value indicating if the first frame is enabled over the current frame: 1 for the first frame flag; otherwise, 0.
int getFirstFrame() const#
Returns the current value indicating if the first frame is enabled over the current frame.
Return value
Current value indicating if the first frame is enabled over the current frame: 1 for the first frame flag; otherwise, 0.void setAspectCorrection ( bool correction ) #
Sets a new value indicating if the aspect correction enabled for current viewport.
Arguments
- bool correction - Set true to enable the aspect correction; false - to disable it.
bool isAspectCorrection() const#
Returns the current value indicating if the aspect correction enabled for current viewport.
Return value
true if the aspect correction is enabled; otherwise false.int getID() const#
Returns the current Viewport ID.
Return value
Current Viewport ID.void setPanoramaFisheyeFov ( float fov ) #
Sets a new field of view angle used for the panorama rendering mode.
Arguments
- float fov - The field of view angle used 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 used for the panorama rendering mode, in degrees.void setEnvironmentTexture ( const Ptr<Texture>& texture ) #
Sets a new cubemap defining the environment color.
Arguments
Ptr<Texture> getEnvironmentTexture() const#
Returns the current cubemap defining the environment color.
Return value
Current cubemap defining the environment color.void setPaused ( bool paused ) #
Sets a new value indicating if the rendering in the current viewport is paused.
Arguments
- bool paused - Set true to enable the viewport paused state; false - to disable it.
bool isPaused() const#
Returns the current value indicating if the rendering in the current viewport is paused.
Return value
true if the viewport paused state is enabled; otherwise false.void setUseTAAOffset ( bool taaoffset ) #
Sets a new
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 taaoffset - Set true to enable skipping render mode check when using TAA; false - to disable it.
bool isUseTAAOffset() const#
Returns the current
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 when using TAA is enabled; otherwise false.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 renderingEvent<> 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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the End event handler
void end_event_handler()
{
Log::message("\Handling End event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections end_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEnd().connect(end_event_connections, end_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEnd().connect(end_event_connections, []() {
Log::message("\Handling End event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
end_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection end_event_connection;
// subscribe to the End event with a handler function keeping the connection
publisher->getEventEnd().connect(end_event_connection, end_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
end_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
end_event_connection.setEnabled(true);
// ...
// remove subscription to the End event via the connection
end_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A End event handler implemented as a class member
void event_handler()
{
Log::message("\Handling End event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEnd().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the End event with a handler function
publisher->getEventEnd().connect(end_event_handler);
// remove subscription to the End event later by the handler function
publisher->getEventEnd().disconnect(end_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId end_handler_id;
// subscribe to the End event with a lambda handler function and keeping connection ID
end_handler_id = publisher->getEventEnd().connect([]() {
Log::message("\Handling End event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEnd().disconnect(end_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all End events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEnd().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEnd().setEnabled(true);Return value
Event reference.Event<> getEventEndScreen() const#
event triggered after the stage of rendering each screen (a stereo image has 2 screens, while a cubemap will have 6). You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndScreen event handler
void endscreen_event_handler()
{
Log::message("\Handling EndScreen event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endscreen_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndScreen().connect(endscreen_event_connections, endscreen_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndScreen().connect(endscreen_event_connections, []() {
Log::message("\Handling EndScreen event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endscreen_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endscreen_event_connection;
// subscribe to the EndScreen event with a handler function keeping the connection
publisher->getEventEndScreen().connect(endscreen_event_connection, endscreen_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endscreen_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endscreen_event_connection.setEnabled(true);
// ...
// remove subscription to the EndScreen event via the connection
endscreen_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndScreen event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndScreen event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndScreen().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndScreen event with a handler function
publisher->getEventEndScreen().connect(endscreen_event_handler);
// remove subscription to the EndScreen event later by the handler function
publisher->getEventEndScreen().disconnect(endscreen_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endscreen_handler_id;
// subscribe to the EndScreen event with a lambda handler function and keeping connection ID
endscreen_handler_id = publisher->getEventEndScreen().connect([]() {
Log::message("\Handling EndScreen event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndScreen().disconnect(endscreen_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndScreen events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndScreen().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndScreen().setEnabled(true);Return value
Event reference.Event<> getEventEndVisualizer() const#
event triggered after the visualizer rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndVisualizer event handler
void endvisualizer_event_handler()
{
Log::message("\Handling EndVisualizer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endvisualizer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndVisualizer().connect(endvisualizer_event_connections, endvisualizer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndVisualizer().connect(endvisualizer_event_connections, []() {
Log::message("\Handling EndVisualizer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endvisualizer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endvisualizer_event_connection;
// subscribe to the EndVisualizer event with a handler function keeping the connection
publisher->getEventEndVisualizer().connect(endvisualizer_event_connection, endvisualizer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endvisualizer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endvisualizer_event_connection.setEnabled(true);
// ...
// remove subscription to the EndVisualizer event via the connection
endvisualizer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndVisualizer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndVisualizer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndVisualizer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndVisualizer event with a handler function
publisher->getEventEndVisualizer().connect(endvisualizer_event_handler);
// remove subscription to the EndVisualizer event later by the handler function
publisher->getEventEndVisualizer().disconnect(endvisualizer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endvisualizer_handler_id;
// subscribe to the EndVisualizer event with a lambda handler function and keeping connection ID
endvisualizer_handler_id = publisher->getEventEndVisualizer().connect([]() {
Log::message("\Handling EndVisualizer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndVisualizer().disconnect(endvisualizer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndVisualizer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndVisualizer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndVisualizer().setEnabled(true);Return value
Event reference.Event<> getEventBeginVisualizer() const#
event triggered before the visualizer rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginVisualizer event handler
void beginvisualizer_event_handler()
{
Log::message("\Handling BeginVisualizer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginvisualizer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginVisualizer().connect(beginvisualizer_event_connections, beginvisualizer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginVisualizer().connect(beginvisualizer_event_connections, []() {
Log::message("\Handling BeginVisualizer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginvisualizer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginvisualizer_event_connection;
// subscribe to the BeginVisualizer event with a handler function keeping the connection
publisher->getEventBeginVisualizer().connect(beginvisualizer_event_connection, beginvisualizer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginvisualizer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginvisualizer_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginVisualizer event via the connection
beginvisualizer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginVisualizer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginVisualizer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginVisualizer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginVisualizer event with a handler function
publisher->getEventBeginVisualizer().connect(beginvisualizer_event_handler);
// remove subscription to the BeginVisualizer event later by the handler function
publisher->getEventBeginVisualizer().disconnect(beginvisualizer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginvisualizer_handler_id;
// subscribe to the BeginVisualizer event with a lambda handler function and keeping connection ID
beginvisualizer_handler_id = publisher->getEventBeginVisualizer().connect([]() {
Log::message("\Handling BeginVisualizer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginVisualizer().disconnect(beginvisualizer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginVisualizer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginVisualizer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginVisualizer().setEnabled(true);Return value
Event reference.Event<> getEventEndDebugMaterials() const#
event triggered after the debug materials stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndDebugMaterials event handler
void enddebugmaterials_event_handler()
{
Log::message("\Handling EndDebugMaterials event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections enddebugmaterials_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndDebugMaterials().connect(enddebugmaterials_event_connections, enddebugmaterials_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndDebugMaterials().connect(enddebugmaterials_event_connections, []() {
Log::message("\Handling EndDebugMaterials event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
enddebugmaterials_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection enddebugmaterials_event_connection;
// subscribe to the EndDebugMaterials event with a handler function keeping the connection
publisher->getEventEndDebugMaterials().connect(enddebugmaterials_event_connection, enddebugmaterials_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
enddebugmaterials_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
enddebugmaterials_event_connection.setEnabled(true);
// ...
// remove subscription to the EndDebugMaterials event via the connection
enddebugmaterials_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndDebugMaterials event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndDebugMaterials event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndDebugMaterials().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndDebugMaterials event with a handler function
publisher->getEventEndDebugMaterials().connect(enddebugmaterials_event_handler);
// remove subscription to the EndDebugMaterials event later by the handler function
publisher->getEventEndDebugMaterials().disconnect(enddebugmaterials_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId enddebugmaterials_handler_id;
// subscribe to the EndDebugMaterials event with a lambda handler function and keeping connection ID
enddebugmaterials_handler_id = publisher->getEventEndDebugMaterials().connect([]() {
Log::message("\Handling EndDebugMaterials event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndDebugMaterials().disconnect(enddebugmaterials_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndDebugMaterials events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndDebugMaterials().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndDebugMaterials().setEnabled(true);Return value
Event reference.Event<> getEventBeginDebugMaterials() const#
event triggered before the debug materials stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginDebugMaterials event handler
void begindebugmaterials_event_handler()
{
Log::message("\Handling BeginDebugMaterials event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections begindebugmaterials_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginDebugMaterials().connect(begindebugmaterials_event_connections, begindebugmaterials_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginDebugMaterials().connect(begindebugmaterials_event_connections, []() {
Log::message("\Handling BeginDebugMaterials event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
begindebugmaterials_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection begindebugmaterials_event_connection;
// subscribe to the BeginDebugMaterials event with a handler function keeping the connection
publisher->getEventBeginDebugMaterials().connect(begindebugmaterials_event_connection, begindebugmaterials_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
begindebugmaterials_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
begindebugmaterials_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginDebugMaterials event via the connection
begindebugmaterials_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginDebugMaterials event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginDebugMaterials event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginDebugMaterials().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginDebugMaterials event with a handler function
publisher->getEventBeginDebugMaterials().connect(begindebugmaterials_event_handler);
// remove subscription to the BeginDebugMaterials event later by the handler function
publisher->getEventBeginDebugMaterials().disconnect(begindebugmaterials_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId begindebugmaterials_handler_id;
// subscribe to the BeginDebugMaterials event with a lambda handler function and keeping connection ID
begindebugmaterials_handler_id = publisher->getEventBeginDebugMaterials().connect([]() {
Log::message("\Handling BeginDebugMaterials event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginDebugMaterials().disconnect(begindebugmaterials_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginDebugMaterials events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginDebugMaterials().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginDebugMaterials().setEnabled(true);Return value
Event reference.Event<> getEventEndPostMaterials() const#
event triggered after the post materials rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndPostMaterials event handler
void endpostmaterials_event_handler()
{
Log::message("\Handling EndPostMaterials event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endpostmaterials_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndPostMaterials().connect(endpostmaterials_event_connections, endpostmaterials_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndPostMaterials().connect(endpostmaterials_event_connections, []() {
Log::message("\Handling EndPostMaterials event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endpostmaterials_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endpostmaterials_event_connection;
// subscribe to the EndPostMaterials event with a handler function keeping the connection
publisher->getEventEndPostMaterials().connect(endpostmaterials_event_connection, endpostmaterials_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endpostmaterials_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endpostmaterials_event_connection.setEnabled(true);
// ...
// remove subscription to the EndPostMaterials event via the connection
endpostmaterials_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndPostMaterials event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndPostMaterials event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndPostMaterials().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndPostMaterials event with a handler function
publisher->getEventEndPostMaterials().connect(endpostmaterials_event_handler);
// remove subscription to the EndPostMaterials event later by the handler function
publisher->getEventEndPostMaterials().disconnect(endpostmaterials_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endpostmaterials_handler_id;
// subscribe to the EndPostMaterials event with a lambda handler function and keeping connection ID
endpostmaterials_handler_id = publisher->getEventEndPostMaterials().connect([]() {
Log::message("\Handling EndPostMaterials event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndPostMaterials().disconnect(endpostmaterials_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndPostMaterials events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndPostMaterials().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndPostMaterials().setEnabled(true);Return value
Event reference.Event<> getEventBeginPostMaterials() const#
event triggered before the post materials rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginPostMaterials event handler
void beginpostmaterials_event_handler()
{
Log::message("\Handling BeginPostMaterials event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginpostmaterials_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginPostMaterials().connect(beginpostmaterials_event_connections, beginpostmaterials_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginPostMaterials().connect(beginpostmaterials_event_connections, []() {
Log::message("\Handling BeginPostMaterials event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginpostmaterials_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginpostmaterials_event_connection;
// subscribe to the BeginPostMaterials event with a handler function keeping the connection
publisher->getEventBeginPostMaterials().connect(beginpostmaterials_event_connection, beginpostmaterials_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginpostmaterials_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginpostmaterials_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginPostMaterials event via the connection
beginpostmaterials_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginPostMaterials event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginPostMaterials event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginPostMaterials().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginPostMaterials event with a handler function
publisher->getEventBeginPostMaterials().connect(beginpostmaterials_event_handler);
// remove subscription to the BeginPostMaterials event later by the handler function
publisher->getEventBeginPostMaterials().disconnect(beginpostmaterials_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginpostmaterials_handler_id;
// subscribe to the BeginPostMaterials event with a lambda handler function and keeping connection ID
beginpostmaterials_handler_id = publisher->getEventBeginPostMaterials().connect([]() {
Log::message("\Handling BeginPostMaterials event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginPostMaterials().disconnect(beginpostmaterials_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginPostMaterials events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginPostMaterials().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginPostMaterials().setEnabled(true);Return value
Event reference.Event<> getEventEndCameraEffects() const#
event triggered after the camera effects stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndCameraEffects event handler
void endcameraeffects_event_handler()
{
Log::message("\Handling EndCameraEffects event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endcameraeffects_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndCameraEffects().connect(endcameraeffects_event_connections, endcameraeffects_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndCameraEffects().connect(endcameraeffects_event_connections, []() {
Log::message("\Handling EndCameraEffects event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endcameraeffects_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endcameraeffects_event_connection;
// subscribe to the EndCameraEffects event with a handler function keeping the connection
publisher->getEventEndCameraEffects().connect(endcameraeffects_event_connection, endcameraeffects_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endcameraeffects_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endcameraeffects_event_connection.setEnabled(true);
// ...
// remove subscription to the EndCameraEffects event via the connection
endcameraeffects_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndCameraEffects event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndCameraEffects event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndCameraEffects().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndCameraEffects event with a handler function
publisher->getEventEndCameraEffects().connect(endcameraeffects_event_handler);
// remove subscription to the EndCameraEffects event later by the handler function
publisher->getEventEndCameraEffects().disconnect(endcameraeffects_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endcameraeffects_handler_id;
// subscribe to the EndCameraEffects event with a lambda handler function and keeping connection ID
endcameraeffects_handler_id = publisher->getEventEndCameraEffects().connect([]() {
Log::message("\Handling EndCameraEffects event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndCameraEffects().disconnect(endcameraeffects_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndCameraEffects events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndCameraEffects().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndCameraEffects().setEnabled(true);Return value
Event reference.Event<> getEventBeginCameraEffects() const#
event triggered before the camera effects stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginCameraEffects event handler
void begincameraeffects_event_handler()
{
Log::message("\Handling BeginCameraEffects event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections begincameraeffects_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginCameraEffects().connect(begincameraeffects_event_connections, begincameraeffects_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginCameraEffects().connect(begincameraeffects_event_connections, []() {
Log::message("\Handling BeginCameraEffects event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
begincameraeffects_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection begincameraeffects_event_connection;
// subscribe to the BeginCameraEffects event with a handler function keeping the connection
publisher->getEventBeginCameraEffects().connect(begincameraeffects_event_connection, begincameraeffects_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
begincameraeffects_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
begincameraeffects_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginCameraEffects event via the connection
begincameraeffects_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginCameraEffects event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginCameraEffects event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginCameraEffects().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginCameraEffects event with a handler function
publisher->getEventBeginCameraEffects().connect(begincameraeffects_event_handler);
// remove subscription to the BeginCameraEffects event later by the handler function
publisher->getEventBeginCameraEffects().disconnect(begincameraeffects_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId begincameraeffects_handler_id;
// subscribe to the BeginCameraEffects event with a lambda handler function and keeping connection ID
begincameraeffects_handler_id = publisher->getEventBeginCameraEffects().connect([]() {
Log::message("\Handling BeginCameraEffects event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginCameraEffects().disconnect(begincameraeffects_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginCameraEffects events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginCameraEffects().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginCameraEffects().setEnabled(true);Return value
Event reference.Event<> getEventEndTAA() const#
event triggered after the Temporal Anti-Aliasing (TAA) pass. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndTAA event handler
void endtaa_event_handler()
{
Log::message("\Handling EndTAA event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endtaa_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndTAA().connect(endtaa_event_connections, endtaa_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndTAA().connect(endtaa_event_connections, []() {
Log::message("\Handling EndTAA event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endtaa_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endtaa_event_connection;
// subscribe to the EndTAA event with a handler function keeping the connection
publisher->getEventEndTAA().connect(endtaa_event_connection, endtaa_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endtaa_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endtaa_event_connection.setEnabled(true);
// ...
// remove subscription to the EndTAA event via the connection
endtaa_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndTAA event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndTAA event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndTAA().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndTAA event with a handler function
publisher->getEventEndTAA().connect(endtaa_event_handler);
// remove subscription to the EndTAA event later by the handler function
publisher->getEventEndTAA().disconnect(endtaa_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endtaa_handler_id;
// subscribe to the EndTAA event with a lambda handler function and keeping connection ID
endtaa_handler_id = publisher->getEventEndTAA().connect([]() {
Log::message("\Handling EndTAA event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndTAA().disconnect(endtaa_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndTAA events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndTAA().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndTAA().setEnabled(true);Return value
Event reference.Event<> getEventBeginTAA() const#
event triggered before the Temporal Anti-Aliasing (TAA) pass. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginTAA event handler
void begintaa_event_handler()
{
Log::message("\Handling BeginTAA event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections begintaa_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginTAA().connect(begintaa_event_connections, begintaa_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginTAA().connect(begintaa_event_connections, []() {
Log::message("\Handling BeginTAA event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
begintaa_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection begintaa_event_connection;
// subscribe to the BeginTAA event with a handler function keeping the connection
publisher->getEventBeginTAA().connect(begintaa_event_connection, begintaa_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
begintaa_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
begintaa_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginTAA event via the connection
begintaa_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginTAA event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginTAA event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginTAA().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginTAA event with a handler function
publisher->getEventBeginTAA().connect(begintaa_event_handler);
// remove subscription to the BeginTAA event later by the handler function
publisher->getEventBeginTAA().disconnect(begintaa_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId begintaa_handler_id;
// subscribe to the BeginTAA event with a lambda handler function and keeping connection ID
begintaa_handler_id = publisher->getEventBeginTAA().connect([]() {
Log::message("\Handling BeginTAA event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginTAA().disconnect(begintaa_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginTAA events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginTAA().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginTAA().setEnabled(true);Return value
Event reference.Event<> getEventEndAdaptationColor() const#
event triggered after the color adaptation rendering stage (automatic exposure and white balance correction). You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndAdaptationColor event handler
void endadaptationcolor_event_handler()
{
Log::message("\Handling EndAdaptationColor event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endadaptationcolor_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndAdaptationColor().connect(endadaptationcolor_event_connections, endadaptationcolor_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndAdaptationColor().connect(endadaptationcolor_event_connections, []() {
Log::message("\Handling EndAdaptationColor event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endadaptationcolor_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endadaptationcolor_event_connection;
// subscribe to the EndAdaptationColor event with a handler function keeping the connection
publisher->getEventEndAdaptationColor().connect(endadaptationcolor_event_connection, endadaptationcolor_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endadaptationcolor_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endadaptationcolor_event_connection.setEnabled(true);
// ...
// remove subscription to the EndAdaptationColor event via the connection
endadaptationcolor_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndAdaptationColor event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndAdaptationColor event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndAdaptationColor().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndAdaptationColor event with a handler function
publisher->getEventEndAdaptationColor().connect(endadaptationcolor_event_handler);
// remove subscription to the EndAdaptationColor event later by the handler function
publisher->getEventEndAdaptationColor().disconnect(endadaptationcolor_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endadaptationcolor_handler_id;
// subscribe to the EndAdaptationColor event with a lambda handler function and keeping connection ID
endadaptationcolor_handler_id = publisher->getEventEndAdaptationColor().connect([]() {
Log::message("\Handling EndAdaptationColor event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndAdaptationColor().disconnect(endadaptationcolor_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndAdaptationColor events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndAdaptationColor().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndAdaptationColor().setEnabled(true);Return value
Event reference.Event<> getEventBeginAdaptationColor() const#
event triggered before the color adaptation rendering stage (automatic exposure and white balance correction). You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginAdaptationColor event handler
void beginadaptationcolor_event_handler()
{
Log::message("\Handling BeginAdaptationColor event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginadaptationcolor_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginAdaptationColor().connect(beginadaptationcolor_event_connections, beginadaptationcolor_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginAdaptationColor().connect(beginadaptationcolor_event_connections, []() {
Log::message("\Handling BeginAdaptationColor event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginadaptationcolor_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginadaptationcolor_event_connection;
// subscribe to the BeginAdaptationColor event with a handler function keeping the connection
publisher->getEventBeginAdaptationColor().connect(beginadaptationcolor_event_connection, beginadaptationcolor_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginadaptationcolor_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginadaptationcolor_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginAdaptationColor event via the connection
beginadaptationcolor_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginAdaptationColor event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginAdaptationColor event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginAdaptationColor().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginAdaptationColor event with a handler function
publisher->getEventBeginAdaptationColor().connect(beginadaptationcolor_event_handler);
// remove subscription to the BeginAdaptationColor event later by the handler function
publisher->getEventBeginAdaptationColor().disconnect(beginadaptationcolor_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginadaptationcolor_handler_id;
// subscribe to the BeginAdaptationColor event with a lambda handler function and keeping connection ID
beginadaptationcolor_handler_id = publisher->getEventBeginAdaptationColor().connect([]() {
Log::message("\Handling BeginAdaptationColor event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginAdaptationColor().disconnect(beginadaptationcolor_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginAdaptationColor events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginAdaptationColor().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginAdaptationColor().setEnabled(true);Return value
Event reference.Event<> getEventEndAdaptationColorAverage() const#
event triggered after the calculation of automatic exposure and white balance correction. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndAdaptationColorAverage event handler
void endadaptationcoloraverage_event_handler()
{
Log::message("\Handling EndAdaptationColorAverage event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endadaptationcoloraverage_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndAdaptationColorAverage().connect(endadaptationcoloraverage_event_connections, endadaptationcoloraverage_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndAdaptationColorAverage().connect(endadaptationcoloraverage_event_connections, []() {
Log::message("\Handling EndAdaptationColorAverage event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endadaptationcoloraverage_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endadaptationcoloraverage_event_connection;
// subscribe to the EndAdaptationColorAverage event with a handler function keeping the connection
publisher->getEventEndAdaptationColorAverage().connect(endadaptationcoloraverage_event_connection, endadaptationcoloraverage_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endadaptationcoloraverage_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endadaptationcoloraverage_event_connection.setEnabled(true);
// ...
// remove subscription to the EndAdaptationColorAverage event via the connection
endadaptationcoloraverage_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndAdaptationColorAverage event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndAdaptationColorAverage event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndAdaptationColorAverage().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndAdaptationColorAverage event with a handler function
publisher->getEventEndAdaptationColorAverage().connect(endadaptationcoloraverage_event_handler);
// remove subscription to the EndAdaptationColorAverage event later by the handler function
publisher->getEventEndAdaptationColorAverage().disconnect(endadaptationcoloraverage_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endadaptationcoloraverage_handler_id;
// subscribe to the EndAdaptationColorAverage event with a lambda handler function and keeping connection ID
endadaptationcoloraverage_handler_id = publisher->getEventEndAdaptationColorAverage().connect([]() {
Log::message("\Handling EndAdaptationColorAverage event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndAdaptationColorAverage().disconnect(endadaptationcoloraverage_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndAdaptationColorAverage events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndAdaptationColorAverage().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndAdaptationColorAverage().setEnabled(true);Return value
Event reference.Event<> getEventBeginAdaptationColorAverage() const#
event triggered before the calculation of automatic exposure and white balance correction. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginAdaptationColorAverage event handler
void beginadaptationcoloraverage_event_handler()
{
Log::message("\Handling BeginAdaptationColorAverage event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginadaptationcoloraverage_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginAdaptationColorAverage().connect(beginadaptationcoloraverage_event_connections, beginadaptationcoloraverage_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginAdaptationColorAverage().connect(beginadaptationcoloraverage_event_connections, []() {
Log::message("\Handling BeginAdaptationColorAverage event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginadaptationcoloraverage_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginadaptationcoloraverage_event_connection;
// subscribe to the BeginAdaptationColorAverage event with a handler function keeping the connection
publisher->getEventBeginAdaptationColorAverage().connect(beginadaptationcoloraverage_event_connection, beginadaptationcoloraverage_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginadaptationcoloraverage_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginadaptationcoloraverage_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginAdaptationColorAverage event via the connection
beginadaptationcoloraverage_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginAdaptationColorAverage event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginAdaptationColorAverage event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginAdaptationColorAverage().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginAdaptationColorAverage event with a handler function
publisher->getEventBeginAdaptationColorAverage().connect(beginadaptationcoloraverage_event_handler);
// remove subscription to the BeginAdaptationColorAverage event later by the handler function
publisher->getEventBeginAdaptationColorAverage().disconnect(beginadaptationcoloraverage_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginadaptationcoloraverage_handler_id;
// subscribe to the BeginAdaptationColorAverage event with a lambda handler function and keeping connection ID
beginadaptationcoloraverage_handler_id = publisher->getEventBeginAdaptationColorAverage().connect([]() {
Log::message("\Handling BeginAdaptationColorAverage event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginAdaptationColorAverage().disconnect(beginadaptationcoloraverage_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginAdaptationColorAverage events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginAdaptationColorAverage().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginAdaptationColorAverage().setEnabled(true);Return value
Event reference.Event<> getEventEndSrgbCorrection() const#
event triggered after the sRGB correction stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndSrgbCorrection event handler
void endsrgbcorrection_event_handler()
{
Log::message("\Handling EndSrgbCorrection event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endsrgbcorrection_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSrgbCorrection().connect(endsrgbcorrection_event_connections, endsrgbcorrection_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSrgbCorrection().connect(endsrgbcorrection_event_connections, []() {
Log::message("\Handling EndSrgbCorrection event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endsrgbcorrection_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endsrgbcorrection_event_connection;
// subscribe to the EndSrgbCorrection event with a handler function keeping the connection
publisher->getEventEndSrgbCorrection().connect(endsrgbcorrection_event_connection, endsrgbcorrection_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endsrgbcorrection_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endsrgbcorrection_event_connection.setEnabled(true);
// ...
// remove subscription to the EndSrgbCorrection event via the connection
endsrgbcorrection_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndSrgbCorrection event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndSrgbCorrection event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSrgbCorrection().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndSrgbCorrection event with a handler function
publisher->getEventEndSrgbCorrection().connect(endsrgbcorrection_event_handler);
// remove subscription to the EndSrgbCorrection event later by the handler function
publisher->getEventEndSrgbCorrection().disconnect(endsrgbcorrection_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endsrgbcorrection_handler_id;
// subscribe to the EndSrgbCorrection event with a lambda handler function and keeping connection ID
endsrgbcorrection_handler_id = publisher->getEventEndSrgbCorrection().connect([]() {
Log::message("\Handling EndSrgbCorrection event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndSrgbCorrection().disconnect(endsrgbcorrection_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndSrgbCorrection events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSrgbCorrection().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndSrgbCorrection().setEnabled(true);Return value
Event reference.Event<> getEventBeginSrgbCorrection() const#
event triggered before the sRGB correction stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginSrgbCorrection event handler
void beginsrgbcorrection_event_handler()
{
Log::message("\Handling BeginSrgbCorrection event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginsrgbcorrection_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSrgbCorrection().connect(beginsrgbcorrection_event_connections, beginsrgbcorrection_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSrgbCorrection().connect(beginsrgbcorrection_event_connections, []() {
Log::message("\Handling BeginSrgbCorrection event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginsrgbcorrection_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginsrgbcorrection_event_connection;
// subscribe to the BeginSrgbCorrection event with a handler function keeping the connection
publisher->getEventBeginSrgbCorrection().connect(beginsrgbcorrection_event_connection, beginsrgbcorrection_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginsrgbcorrection_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginsrgbcorrection_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginSrgbCorrection event via the connection
beginsrgbcorrection_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginSrgbCorrection event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginSrgbCorrection event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSrgbCorrection().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginSrgbCorrection event with a handler function
publisher->getEventBeginSrgbCorrection().connect(beginsrgbcorrection_event_handler);
// remove subscription to the BeginSrgbCorrection event later by the handler function
publisher->getEventBeginSrgbCorrection().disconnect(beginsrgbcorrection_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginsrgbcorrection_handler_id;
// subscribe to the BeginSrgbCorrection event with a lambda handler function and keeping connection ID
beginsrgbcorrection_handler_id = publisher->getEventBeginSrgbCorrection().connect([]() {
Log::message("\Handling BeginSrgbCorrection event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginSrgbCorrection().disconnect(beginsrgbcorrection_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginSrgbCorrection events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSrgbCorrection().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginSrgbCorrection().setEnabled(true);Return value
Event reference.Event<> getEventEndTransparent() const#
event triggered after the transparent objects rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndTransparent event handler
void endtransparent_event_handler()
{
Log::message("\Handling EndTransparent event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endtransparent_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndTransparent().connect(endtransparent_event_connections, endtransparent_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndTransparent().connect(endtransparent_event_connections, []() {
Log::message("\Handling EndTransparent event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endtransparent_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endtransparent_event_connection;
// subscribe to the EndTransparent event with a handler function keeping the connection
publisher->getEventEndTransparent().connect(endtransparent_event_connection, endtransparent_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endtransparent_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endtransparent_event_connection.setEnabled(true);
// ...
// remove subscription to the EndTransparent event via the connection
endtransparent_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndTransparent event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndTransparent event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndTransparent().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndTransparent event with a handler function
publisher->getEventEndTransparent().connect(endtransparent_event_handler);
// remove subscription to the EndTransparent event later by the handler function
publisher->getEventEndTransparent().disconnect(endtransparent_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endtransparent_handler_id;
// subscribe to the EndTransparent event with a lambda handler function and keeping connection ID
endtransparent_handler_id = publisher->getEventEndTransparent().connect([]() {
Log::message("\Handling EndTransparent event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndTransparent().disconnect(endtransparent_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndTransparent events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndTransparent().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndTransparent().setEnabled(true);Return value
Event reference.Event<> getEventEndWater() const#
event triggered after the water rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndWater event handler
void endwater_event_handler()
{
Log::message("\Handling EndWater event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endwater_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWater().connect(endwater_event_connections, endwater_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWater().connect(endwater_event_connections, []() {
Log::message("\Handling EndWater event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endwater_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endwater_event_connection;
// subscribe to the EndWater event with a handler function keeping the connection
publisher->getEventEndWater().connect(endwater_event_connection, endwater_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endwater_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endwater_event_connection.setEnabled(true);
// ...
// remove subscription to the EndWater event via the connection
endwater_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndWater event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndWater event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWater().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndWater event with a handler function
publisher->getEventEndWater().connect(endwater_event_handler);
// remove subscription to the EndWater event later by the handler function
publisher->getEventEndWater().disconnect(endwater_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endwater_handler_id;
// subscribe to the EndWater event with a lambda handler function and keeping connection ID
endwater_handler_id = publisher->getEventEndWater().connect([]() {
Log::message("\Handling EndWater event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndWater().disconnect(endwater_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndWater events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWater().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndWater().setEnabled(true);Return value
Event reference.Event<> getEventEndWaterPlanarProbes() const#
event triggered after the water planar probes rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndWaterPlanarProbes event handler
void endwaterplanarprobes_event_handler()
{
Log::message("\Handling EndWaterPlanarProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endwaterplanarprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWaterPlanarProbes().connect(endwaterplanarprobes_event_connections, endwaterplanarprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWaterPlanarProbes().connect(endwaterplanarprobes_event_connections, []() {
Log::message("\Handling EndWaterPlanarProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endwaterplanarprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endwaterplanarprobes_event_connection;
// subscribe to the EndWaterPlanarProbes event with a handler function keeping the connection
publisher->getEventEndWaterPlanarProbes().connect(endwaterplanarprobes_event_connection, endwaterplanarprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endwaterplanarprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endwaterplanarprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the EndWaterPlanarProbes event via the connection
endwaterplanarprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndWaterPlanarProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndWaterPlanarProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWaterPlanarProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndWaterPlanarProbes event with a handler function
publisher->getEventEndWaterPlanarProbes().connect(endwaterplanarprobes_event_handler);
// remove subscription to the EndWaterPlanarProbes event later by the handler function
publisher->getEventEndWaterPlanarProbes().disconnect(endwaterplanarprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endwaterplanarprobes_handler_id;
// subscribe to the EndWaterPlanarProbes event with a lambda handler function and keeping connection ID
endwaterplanarprobes_handler_id = publisher->getEventEndWaterPlanarProbes().connect([]() {
Log::message("\Handling EndWaterPlanarProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndWaterPlanarProbes().disconnect(endwaterplanarprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndWaterPlanarProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWaterPlanarProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndWaterPlanarProbes().setEnabled(true);Return value
Event reference.Event<> getEventBeginWaterPlanarProbes() const#
event triggered before the water planar probes rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginWaterPlanarProbes event handler
void beginwaterplanarprobes_event_handler()
{
Log::message("\Handling BeginWaterPlanarProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginwaterplanarprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWaterPlanarProbes().connect(beginwaterplanarprobes_event_connections, beginwaterplanarprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWaterPlanarProbes().connect(beginwaterplanarprobes_event_connections, []() {
Log::message("\Handling BeginWaterPlanarProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginwaterplanarprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginwaterplanarprobes_event_connection;
// subscribe to the BeginWaterPlanarProbes event with a handler function keeping the connection
publisher->getEventBeginWaterPlanarProbes().connect(beginwaterplanarprobes_event_connection, beginwaterplanarprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginwaterplanarprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginwaterplanarprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginWaterPlanarProbes event via the connection
beginwaterplanarprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginWaterPlanarProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginWaterPlanarProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWaterPlanarProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginWaterPlanarProbes event with a handler function
publisher->getEventBeginWaterPlanarProbes().connect(beginwaterplanarprobes_event_handler);
// remove subscription to the BeginWaterPlanarProbes event later by the handler function
publisher->getEventBeginWaterPlanarProbes().disconnect(beginwaterplanarprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginwaterplanarprobes_handler_id;
// subscribe to the BeginWaterPlanarProbes event with a lambda handler function and keeping connection ID
beginwaterplanarprobes_handler_id = publisher->getEventBeginWaterPlanarProbes().connect([]() {
Log::message("\Handling BeginWaterPlanarProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginWaterPlanarProbes().disconnect(beginwaterplanarprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginWaterPlanarProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWaterPlanarProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginWaterPlanarProbes().setEnabled(true);Return value
Event reference.Event<> getEventEndWaterEnvironmentProbes() const#
event triggered after the water environment probes rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndWaterEnvironmentProbes event handler
void endwaterenvironmentprobes_event_handler()
{
Log::message("\Handling EndWaterEnvironmentProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endwaterenvironmentprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWaterEnvironmentProbes().connect(endwaterenvironmentprobes_event_connections, endwaterenvironmentprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWaterEnvironmentProbes().connect(endwaterenvironmentprobes_event_connections, []() {
Log::message("\Handling EndWaterEnvironmentProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endwaterenvironmentprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endwaterenvironmentprobes_event_connection;
// subscribe to the EndWaterEnvironmentProbes event with a handler function keeping the connection
publisher->getEventEndWaterEnvironmentProbes().connect(endwaterenvironmentprobes_event_connection, endwaterenvironmentprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endwaterenvironmentprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endwaterenvironmentprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the EndWaterEnvironmentProbes event via the connection
endwaterenvironmentprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndWaterEnvironmentProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndWaterEnvironmentProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWaterEnvironmentProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndWaterEnvironmentProbes event with a handler function
publisher->getEventEndWaterEnvironmentProbes().connect(endwaterenvironmentprobes_event_handler);
// remove subscription to the EndWaterEnvironmentProbes event later by the handler function
publisher->getEventEndWaterEnvironmentProbes().disconnect(endwaterenvironmentprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endwaterenvironmentprobes_handler_id;
// subscribe to the EndWaterEnvironmentProbes event with a lambda handler function and keeping connection ID
endwaterenvironmentprobes_handler_id = publisher->getEventEndWaterEnvironmentProbes().connect([]() {
Log::message("\Handling EndWaterEnvironmentProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndWaterEnvironmentProbes().disconnect(endwaterenvironmentprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndWaterEnvironmentProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWaterEnvironmentProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndWaterEnvironmentProbes().setEnabled(true);Return value
Event reference.Event<> getEventBeginWaterEnvironmentProbes() const#
event triggered before the water environment probes rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginWaterEnvironmentProbes event handler
void beginwaterenvironmentprobes_event_handler()
{
Log::message("\Handling BeginWaterEnvironmentProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginwaterenvironmentprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWaterEnvironmentProbes().connect(beginwaterenvironmentprobes_event_connections, beginwaterenvironmentprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWaterEnvironmentProbes().connect(beginwaterenvironmentprobes_event_connections, []() {
Log::message("\Handling BeginWaterEnvironmentProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginwaterenvironmentprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginwaterenvironmentprobes_event_connection;
// subscribe to the BeginWaterEnvironmentProbes event with a handler function keeping the connection
publisher->getEventBeginWaterEnvironmentProbes().connect(beginwaterenvironmentprobes_event_connection, beginwaterenvironmentprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginwaterenvironmentprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginwaterenvironmentprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginWaterEnvironmentProbes event via the connection
beginwaterenvironmentprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginWaterEnvironmentProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginWaterEnvironmentProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWaterEnvironmentProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginWaterEnvironmentProbes event with a handler function
publisher->getEventBeginWaterEnvironmentProbes().connect(beginwaterenvironmentprobes_event_handler);
// remove subscription to the BeginWaterEnvironmentProbes event later by the handler function
publisher->getEventBeginWaterEnvironmentProbes().disconnect(beginwaterenvironmentprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginwaterenvironmentprobes_handler_id;
// subscribe to the BeginWaterEnvironmentProbes event with a lambda handler function and keeping connection ID
beginwaterenvironmentprobes_handler_id = publisher->getEventBeginWaterEnvironmentProbes().connect([]() {
Log::message("\Handling BeginWaterEnvironmentProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginWaterEnvironmentProbes().disconnect(beginwaterenvironmentprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginWaterEnvironmentProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWaterEnvironmentProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginWaterEnvironmentProbes().setEnabled(true);Return value
Event reference.Event<> getEventEndWaterVoxelProbes() const#
event triggered after the water voxel probes rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndWaterVoxelProbes event handler
void endwatervoxelprobes_event_handler()
{
Log::message("\Handling EndWaterVoxelProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endwatervoxelprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWaterVoxelProbes().connect(endwatervoxelprobes_event_connections, endwatervoxelprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWaterVoxelProbes().connect(endwatervoxelprobes_event_connections, []() {
Log::message("\Handling EndWaterVoxelProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endwatervoxelprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endwatervoxelprobes_event_connection;
// subscribe to the EndWaterVoxelProbes event with a handler function keeping the connection
publisher->getEventEndWaterVoxelProbes().connect(endwatervoxelprobes_event_connection, endwatervoxelprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endwatervoxelprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endwatervoxelprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the EndWaterVoxelProbes event via the connection
endwatervoxelprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndWaterVoxelProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndWaterVoxelProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWaterVoxelProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndWaterVoxelProbes event with a handler function
publisher->getEventEndWaterVoxelProbes().connect(endwatervoxelprobes_event_handler);
// remove subscription to the EndWaterVoxelProbes event later by the handler function
publisher->getEventEndWaterVoxelProbes().disconnect(endwatervoxelprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endwatervoxelprobes_handler_id;
// subscribe to the EndWaterVoxelProbes event with a lambda handler function and keeping connection ID
endwatervoxelprobes_handler_id = publisher->getEventEndWaterVoxelProbes().connect([]() {
Log::message("\Handling EndWaterVoxelProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndWaterVoxelProbes().disconnect(endwatervoxelprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndWaterVoxelProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWaterVoxelProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndWaterVoxelProbes().setEnabled(true);Return value
Event reference.Event<> getEventBeginWaterVoxelProbes() const#
event triggered before the water voxel probes rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginWaterVoxelProbes event handler
void beginwatervoxelprobes_event_handler()
{
Log::message("\Handling BeginWaterVoxelProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginwatervoxelprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWaterVoxelProbes().connect(beginwatervoxelprobes_event_connections, beginwatervoxelprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWaterVoxelProbes().connect(beginwatervoxelprobes_event_connections, []() {
Log::message("\Handling BeginWaterVoxelProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginwatervoxelprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginwatervoxelprobes_event_connection;
// subscribe to the BeginWaterVoxelProbes event with a handler function keeping the connection
publisher->getEventBeginWaterVoxelProbes().connect(beginwatervoxelprobes_event_connection, beginwatervoxelprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginwatervoxelprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginwatervoxelprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginWaterVoxelProbes event via the connection
beginwatervoxelprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginWaterVoxelProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginWaterVoxelProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWaterVoxelProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginWaterVoxelProbes event with a handler function
publisher->getEventBeginWaterVoxelProbes().connect(beginwatervoxelprobes_event_handler);
// remove subscription to the BeginWaterVoxelProbes event later by the handler function
publisher->getEventBeginWaterVoxelProbes().disconnect(beginwatervoxelprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginwatervoxelprobes_handler_id;
// subscribe to the BeginWaterVoxelProbes event with a lambda handler function and keeping connection ID
beginwatervoxelprobes_handler_id = publisher->getEventBeginWaterVoxelProbes().connect([]() {
Log::message("\Handling BeginWaterVoxelProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginWaterVoxelProbes().disconnect(beginwatervoxelprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginWaterVoxelProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWaterVoxelProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginWaterVoxelProbes().setEnabled(true);Return value
Event reference.Event<> getEventEndWaterLights() const#
event triggered after the water lights rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndWaterLights event handler
void endwaterlights_event_handler()
{
Log::message("\Handling EndWaterLights event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endwaterlights_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWaterLights().connect(endwaterlights_event_connections, endwaterlights_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWaterLights().connect(endwaterlights_event_connections, []() {
Log::message("\Handling EndWaterLights event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endwaterlights_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endwaterlights_event_connection;
// subscribe to the EndWaterLights event with a handler function keeping the connection
publisher->getEventEndWaterLights().connect(endwaterlights_event_connection, endwaterlights_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endwaterlights_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endwaterlights_event_connection.setEnabled(true);
// ...
// remove subscription to the EndWaterLights event via the connection
endwaterlights_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndWaterLights event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndWaterLights event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWaterLights().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndWaterLights event with a handler function
publisher->getEventEndWaterLights().connect(endwaterlights_event_handler);
// remove subscription to the EndWaterLights event later by the handler function
publisher->getEventEndWaterLights().disconnect(endwaterlights_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endwaterlights_handler_id;
// subscribe to the EndWaterLights event with a lambda handler function and keeping connection ID
endwaterlights_handler_id = publisher->getEventEndWaterLights().connect([]() {
Log::message("\Handling EndWaterLights event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndWaterLights().disconnect(endwaterlights_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndWaterLights events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWaterLights().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndWaterLights().setEnabled(true);Return value
Event reference.Event<> getEventBeginWaterLights() const#
event triggered before the water lights rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginWaterLights event handler
void beginwaterlights_event_handler()
{
Log::message("\Handling BeginWaterLights event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginwaterlights_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWaterLights().connect(beginwaterlights_event_connections, beginwaterlights_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWaterLights().connect(beginwaterlights_event_connections, []() {
Log::message("\Handling BeginWaterLights event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginwaterlights_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginwaterlights_event_connection;
// subscribe to the BeginWaterLights event with a handler function keeping the connection
publisher->getEventBeginWaterLights().connect(beginwaterlights_event_connection, beginwaterlights_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginwaterlights_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginwaterlights_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginWaterLights event via the connection
beginwaterlights_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginWaterLights event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginWaterLights event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWaterLights().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginWaterLights event with a handler function
publisher->getEventBeginWaterLights().connect(beginwaterlights_event_handler);
// remove subscription to the BeginWaterLights event later by the handler function
publisher->getEventBeginWaterLights().disconnect(beginwaterlights_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginwaterlights_handler_id;
// subscribe to the BeginWaterLights event with a lambda handler function and keeping connection ID
beginwaterlights_handler_id = publisher->getEventBeginWaterLights().connect([]() {
Log::message("\Handling BeginWaterLights event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginWaterLights().disconnect(beginwaterlights_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginWaterLights events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWaterLights().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginWaterLights().setEnabled(true);Return value
Event reference.Event<> getEventEndWaterDecals() const#
event triggered after the water decals rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndWaterDecals event handler
void endwaterdecals_event_handler()
{
Log::message("\Handling EndWaterDecals event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endwaterdecals_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWaterDecals().connect(endwaterdecals_event_connections, endwaterdecals_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWaterDecals().connect(endwaterdecals_event_connections, []() {
Log::message("\Handling EndWaterDecals event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endwaterdecals_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endwaterdecals_event_connection;
// subscribe to the EndWaterDecals event with a handler function keeping the connection
publisher->getEventEndWaterDecals().connect(endwaterdecals_event_connection, endwaterdecals_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endwaterdecals_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endwaterdecals_event_connection.setEnabled(true);
// ...
// remove subscription to the EndWaterDecals event via the connection
endwaterdecals_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndWaterDecals event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndWaterDecals event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWaterDecals().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndWaterDecals event with a handler function
publisher->getEventEndWaterDecals().connect(endwaterdecals_event_handler);
// remove subscription to the EndWaterDecals event later by the handler function
publisher->getEventEndWaterDecals().disconnect(endwaterdecals_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endwaterdecals_handler_id;
// subscribe to the EndWaterDecals event with a lambda handler function and keeping connection ID
endwaterdecals_handler_id = publisher->getEventEndWaterDecals().connect([]() {
Log::message("\Handling EndWaterDecals event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndWaterDecals().disconnect(endwaterdecals_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndWaterDecals events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWaterDecals().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndWaterDecals().setEnabled(true);Return value
Event reference.Event<> getEventBeginWaterDecals() const#
event triggered before the water decals rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginWaterDecals event handler
void beginwaterdecals_event_handler()
{
Log::message("\Handling BeginWaterDecals event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginwaterdecals_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWaterDecals().connect(beginwaterdecals_event_connections, beginwaterdecals_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWaterDecals().connect(beginwaterdecals_event_connections, []() {
Log::message("\Handling BeginWaterDecals event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginwaterdecals_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginwaterdecals_event_connection;
// subscribe to the BeginWaterDecals event with a handler function keeping the connection
publisher->getEventBeginWaterDecals().connect(beginwaterdecals_event_connection, beginwaterdecals_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginwaterdecals_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginwaterdecals_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginWaterDecals event via the connection
beginwaterdecals_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginWaterDecals event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginWaterDecals event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWaterDecals().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginWaterDecals event with a handler function
publisher->getEventBeginWaterDecals().connect(beginwaterdecals_event_handler);
// remove subscription to the BeginWaterDecals event later by the handler function
publisher->getEventBeginWaterDecals().disconnect(beginwaterdecals_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginwaterdecals_handler_id;
// subscribe to the BeginWaterDecals event with a lambda handler function and keeping connection ID
beginwaterdecals_handler_id = publisher->getEventBeginWaterDecals().connect([]() {
Log::message("\Handling BeginWaterDecals event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginWaterDecals().disconnect(beginwaterdecals_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginWaterDecals events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWaterDecals().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginWaterDecals().setEnabled(true);Return value
Event reference.Event<> getEventBeginWater() const#
event triggered before the water rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginWater event handler
void beginwater_event_handler()
{
Log::message("\Handling BeginWater event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginwater_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWater().connect(beginwater_event_connections, beginwater_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWater().connect(beginwater_event_connections, []() {
Log::message("\Handling BeginWater event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginwater_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginwater_event_connection;
// subscribe to the BeginWater event with a handler function keeping the connection
publisher->getEventBeginWater().connect(beginwater_event_connection, beginwater_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginwater_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginwater_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginWater event via the connection
beginwater_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginWater event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginWater event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWater().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginWater event with a handler function
publisher->getEventBeginWater().connect(beginwater_event_handler);
// remove subscription to the BeginWater event later by the handler function
publisher->getEventBeginWater().disconnect(beginwater_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginwater_handler_id;
// subscribe to the BeginWater event with a lambda handler function and keeping connection ID
beginwater_handler_id = publisher->getEventBeginWater().connect([]() {
Log::message("\Handling BeginWater event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginWater().disconnect(beginwater_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginWater events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWater().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginWater().setEnabled(true);Return value
Event reference.Event<> getEventEndClouds() const#
event triggered after the clouds rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndClouds event handler
void endclouds_event_handler()
{
Log::message("\Handling EndClouds event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endclouds_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndClouds().connect(endclouds_event_connections, endclouds_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndClouds().connect(endclouds_event_connections, []() {
Log::message("\Handling EndClouds event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endclouds_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endclouds_event_connection;
// subscribe to the EndClouds event with a handler function keeping the connection
publisher->getEventEndClouds().connect(endclouds_event_connection, endclouds_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endclouds_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endclouds_event_connection.setEnabled(true);
// ...
// remove subscription to the EndClouds event via the connection
endclouds_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndClouds event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndClouds event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndClouds().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndClouds event with a handler function
publisher->getEventEndClouds().connect(endclouds_event_handler);
// remove subscription to the EndClouds event later by the handler function
publisher->getEventEndClouds().disconnect(endclouds_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endclouds_handler_id;
// subscribe to the EndClouds event with a lambda handler function and keeping connection ID
endclouds_handler_id = publisher->getEventEndClouds().connect([]() {
Log::message("\Handling EndClouds event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndClouds().disconnect(endclouds_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndClouds events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndClouds().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndClouds().setEnabled(true);Return value
Event reference.Event<> getEventBeginClouds() const#
event triggered before the clouds rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginClouds event handler
void beginclouds_event_handler()
{
Log::message("\Handling BeginClouds event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginclouds_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginClouds().connect(beginclouds_event_connections, beginclouds_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginClouds().connect(beginclouds_event_connections, []() {
Log::message("\Handling BeginClouds event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginclouds_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginclouds_event_connection;
// subscribe to the BeginClouds event with a handler function keeping the connection
publisher->getEventBeginClouds().connect(beginclouds_event_connection, beginclouds_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginclouds_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginclouds_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginClouds event via the connection
beginclouds_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginClouds event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginClouds event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginClouds().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginClouds event with a handler function
publisher->getEventBeginClouds().connect(beginclouds_event_handler);
// remove subscription to the BeginClouds event later by the handler function
publisher->getEventBeginClouds().disconnect(beginclouds_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginclouds_handler_id;
// subscribe to the BeginClouds event with a lambda handler function and keeping connection ID
beginclouds_handler_id = publisher->getEventBeginClouds().connect([]() {
Log::message("\Handling BeginClouds event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginClouds().disconnect(beginclouds_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginClouds events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginClouds().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginClouds().setEnabled(true);Return value
Event reference.Event<> getEventBeginTransparent() const#
event triggered before the transparent objects rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginTransparent event handler
void begintransparent_event_handler()
{
Log::message("\Handling BeginTransparent event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections begintransparent_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginTransparent().connect(begintransparent_event_connections, begintransparent_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginTransparent().connect(begintransparent_event_connections, []() {
Log::message("\Handling BeginTransparent event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
begintransparent_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection begintransparent_event_connection;
// subscribe to the BeginTransparent event with a handler function keeping the connection
publisher->getEventBeginTransparent().connect(begintransparent_event_connection, begintransparent_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
begintransparent_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
begintransparent_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginTransparent event via the connection
begintransparent_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginTransparent event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginTransparent event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginTransparent().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginTransparent event with a handler function
publisher->getEventBeginTransparent().connect(begintransparent_event_handler);
// remove subscription to the BeginTransparent event later by the handler function
publisher->getEventBeginTransparent().disconnect(begintransparent_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId begintransparent_handler_id;
// subscribe to the BeginTransparent event with a lambda handler function and keeping connection ID
begintransparent_handler_id = publisher->getEventBeginTransparent().connect([]() {
Log::message("\Handling BeginTransparent event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginTransparent().disconnect(begintransparent_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginTransparent events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginTransparent().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginTransparent().setEnabled(true);Return value
Event reference.Event<> getEventEndCompositeDeferred() const#
event triggered after the clouds deferred composite stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndCompositeDeferred event handler
void endcompositedeferred_event_handler()
{
Log::message("\Handling EndCompositeDeferred event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endcompositedeferred_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndCompositeDeferred().connect(endcompositedeferred_event_connections, endcompositedeferred_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndCompositeDeferred().connect(endcompositedeferred_event_connections, []() {
Log::message("\Handling EndCompositeDeferred event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endcompositedeferred_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endcompositedeferred_event_connection;
// subscribe to the EndCompositeDeferred event with a handler function keeping the connection
publisher->getEventEndCompositeDeferred().connect(endcompositedeferred_event_connection, endcompositedeferred_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endcompositedeferred_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endcompositedeferred_event_connection.setEnabled(true);
// ...
// remove subscription to the EndCompositeDeferred event via the connection
endcompositedeferred_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndCompositeDeferred event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndCompositeDeferred event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndCompositeDeferred().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndCompositeDeferred event with a handler function
publisher->getEventEndCompositeDeferred().connect(endcompositedeferred_event_handler);
// remove subscription to the EndCompositeDeferred event later by the handler function
publisher->getEventEndCompositeDeferred().disconnect(endcompositedeferred_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endcompositedeferred_handler_id;
// subscribe to the EndCompositeDeferred event with a lambda handler function and keeping connection ID
endcompositedeferred_handler_id = publisher->getEventEndCompositeDeferred().connect([]() {
Log::message("\Handling EndCompositeDeferred event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndCompositeDeferred().disconnect(endcompositedeferred_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndCompositeDeferred events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndCompositeDeferred().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndCompositeDeferred().setEnabled(true);Return value
Event reference.Event<> getEventBeginCompositeDeferred() const#
event triggered before the clouds deferred composite stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginCompositeDeferred event handler
void begincompositedeferred_event_handler()
{
Log::message("\Handling BeginCompositeDeferred event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections begincompositedeferred_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginCompositeDeferred().connect(begincompositedeferred_event_connections, begincompositedeferred_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginCompositeDeferred().connect(begincompositedeferred_event_connections, []() {
Log::message("\Handling BeginCompositeDeferred event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
begincompositedeferred_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection begincompositedeferred_event_connection;
// subscribe to the BeginCompositeDeferred event with a handler function keeping the connection
publisher->getEventBeginCompositeDeferred().connect(begincompositedeferred_event_connection, begincompositedeferred_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
begincompositedeferred_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
begincompositedeferred_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginCompositeDeferred event via the connection
begincompositedeferred_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginCompositeDeferred event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginCompositeDeferred event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginCompositeDeferred().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginCompositeDeferred event with a handler function
publisher->getEventBeginCompositeDeferred().connect(begincompositedeferred_event_handler);
// remove subscription to the BeginCompositeDeferred event later by the handler function
publisher->getEventBeginCompositeDeferred().disconnect(begincompositedeferred_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId begincompositedeferred_handler_id;
// subscribe to the BeginCompositeDeferred event with a lambda handler function and keeping connection ID
begincompositedeferred_handler_id = publisher->getEventBeginCompositeDeferred().connect([]() {
Log::message("\Handling BeginCompositeDeferred event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginCompositeDeferred().disconnect(begincompositedeferred_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginCompositeDeferred events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginCompositeDeferred().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginCompositeDeferred().setEnabled(true);Return value
Event reference.Event<> getEventEndSky() const#
event triggered after the sky rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndSky event handler
void endsky_event_handler()
{
Log::message("\Handling EndSky event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endsky_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSky().connect(endsky_event_connections, endsky_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSky().connect(endsky_event_connections, []() {
Log::message("\Handling EndSky event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endsky_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endsky_event_connection;
// subscribe to the EndSky event with a handler function keeping the connection
publisher->getEventEndSky().connect(endsky_event_connection, endsky_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endsky_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endsky_event_connection.setEnabled(true);
// ...
// remove subscription to the EndSky event via the connection
endsky_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndSky event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndSky event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSky().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndSky event with a handler function
publisher->getEventEndSky().connect(endsky_event_handler);
// remove subscription to the EndSky event later by the handler function
publisher->getEventEndSky().disconnect(endsky_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endsky_handler_id;
// subscribe to the EndSky event with a lambda handler function and keeping connection ID
endsky_handler_id = publisher->getEventEndSky().connect([]() {
Log::message("\Handling EndSky event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndSky().disconnect(endsky_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndSky events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSky().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndSky().setEnabled(true);Return value
Event reference.Event<> getEventBeginSky() const#
event triggered before the sky rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginSky event handler
void beginsky_event_handler()
{
Log::message("\Handling BeginSky event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginsky_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSky().connect(beginsky_event_connections, beginsky_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSky().connect(beginsky_event_connections, []() {
Log::message("\Handling BeginSky event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginsky_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginsky_event_connection;
// subscribe to the BeginSky event with a handler function keeping the connection
publisher->getEventBeginSky().connect(beginsky_event_connection, beginsky_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginsky_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginsky_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginSky event via the connection
beginsky_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginSky event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginSky event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSky().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginSky event with a handler function
publisher->getEventBeginSky().connect(beginsky_event_handler);
// remove subscription to the BeginSky event later by the handler function
publisher->getEventBeginSky().disconnect(beginsky_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginsky_handler_id;
// subscribe to the BeginSky event with a lambda handler function and keeping connection ID
beginsky_handler_id = publisher->getEventBeginSky().connect([]() {
Log::message("\Handling BeginSky event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginSky().disconnect(beginsky_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginSky events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSky().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginSky().setEnabled(true);Return value
Event reference.Event<> getEventEndSSGI() const#
event triggered after the SSGI rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndSSGI event handler
void endssgi_event_handler()
{
Log::message("\Handling EndSSGI event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endssgi_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSSGI().connect(endssgi_event_connections, endssgi_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSSGI().connect(endssgi_event_connections, []() {
Log::message("\Handling EndSSGI event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endssgi_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endssgi_event_connection;
// subscribe to the EndSSGI event with a handler function keeping the connection
publisher->getEventEndSSGI().connect(endssgi_event_connection, endssgi_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endssgi_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endssgi_event_connection.setEnabled(true);
// ...
// remove subscription to the EndSSGI event via the connection
endssgi_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndSSGI event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndSSGI event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSSGI().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndSSGI event with a handler function
publisher->getEventEndSSGI().connect(endssgi_event_handler);
// remove subscription to the EndSSGI event later by the handler function
publisher->getEventEndSSGI().disconnect(endssgi_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endssgi_handler_id;
// subscribe to the EndSSGI event with a lambda handler function and keeping connection ID
endssgi_handler_id = publisher->getEventEndSSGI().connect([]() {
Log::message("\Handling EndSSGI event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndSSGI().disconnect(endssgi_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndSSGI events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSSGI().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndSSGI().setEnabled(true);Return value
Event reference.Event<> getEventBeginSSGI() const#
event triggered before the SSGI rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginSSGI event handler
void beginssgi_event_handler()
{
Log::message("\Handling BeginSSGI event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginssgi_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSSGI().connect(beginssgi_event_connections, beginssgi_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSSGI().connect(beginssgi_event_connections, []() {
Log::message("\Handling BeginSSGI event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginssgi_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginssgi_event_connection;
// subscribe to the BeginSSGI event with a handler function keeping the connection
publisher->getEventBeginSSGI().connect(beginssgi_event_connection, beginssgi_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginssgi_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginssgi_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginSSGI event via the connection
beginssgi_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginSSGI event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginSSGI event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSSGI().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginSSGI event with a handler function
publisher->getEventBeginSSGI().connect(beginssgi_event_handler);
// remove subscription to the BeginSSGI event later by the handler function
publisher->getEventBeginSSGI().disconnect(beginssgi_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginssgi_handler_id;
// subscribe to the BeginSSGI event with a lambda handler function and keeping connection ID
beginssgi_handler_id = publisher->getEventBeginSSGI().connect([]() {
Log::message("\Handling BeginSSGI event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginSSGI().disconnect(beginssgi_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginSSGI events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSSGI().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginSSGI().setEnabled(true);Return value
Event reference.Event<> getEventEndSSAO() const#
event triggered after the SSAO rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndSSAO event handler
void endssao_event_handler()
{
Log::message("\Handling EndSSAO event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endssao_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSSAO().connect(endssao_event_connections, endssao_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSSAO().connect(endssao_event_connections, []() {
Log::message("\Handling EndSSAO event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endssao_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endssao_event_connection;
// subscribe to the EndSSAO event with a handler function keeping the connection
publisher->getEventEndSSAO().connect(endssao_event_connection, endssao_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endssao_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endssao_event_connection.setEnabled(true);
// ...
// remove subscription to the EndSSAO event via the connection
endssao_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndSSAO event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndSSAO event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSSAO().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndSSAO event with a handler function
publisher->getEventEndSSAO().connect(endssao_event_handler);
// remove subscription to the EndSSAO event later by the handler function
publisher->getEventEndSSAO().disconnect(endssao_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endssao_handler_id;
// subscribe to the EndSSAO event with a lambda handler function and keeping connection ID
endssao_handler_id = publisher->getEventEndSSAO().connect([]() {
Log::message("\Handling EndSSAO event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndSSAO().disconnect(endssao_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndSSAO events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSSAO().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndSSAO().setEnabled(true);Return value
Event reference.Event<> getEventBeginSSAO() const#
event triggered before the SSAO rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginSSAO event handler
void beginssao_event_handler()
{
Log::message("\Handling BeginSSAO event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginssao_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSSAO().connect(beginssao_event_connections, beginssao_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSSAO().connect(beginssao_event_connections, []() {
Log::message("\Handling BeginSSAO event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginssao_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginssao_event_connection;
// subscribe to the BeginSSAO event with a handler function keeping the connection
publisher->getEventBeginSSAO().connect(beginssao_event_connection, beginssao_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginssao_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginssao_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginSSAO event via the connection
beginssao_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginSSAO event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginSSAO event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSSAO().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginSSAO event with a handler function
publisher->getEventBeginSSAO().connect(beginssao_event_handler);
// remove subscription to the BeginSSAO event later by the handler function
publisher->getEventBeginSSAO().disconnect(beginssao_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginssao_handler_id;
// subscribe to the BeginSSAO event with a lambda handler function and keeping connection ID
beginssao_handler_id = publisher->getEventBeginSSAO().connect([]() {
Log::message("\Handling BeginSSAO event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginSSAO().disconnect(beginssao_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginSSAO events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSSAO().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginSSAO().setEnabled(true);Return value
Event reference.Event<> getEventEndSSR() const#
event triggered after the SSR rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndSSR event handler
void endssr_event_handler()
{
Log::message("\Handling EndSSR event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endssr_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSSR().connect(endssr_event_connections, endssr_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSSR().connect(endssr_event_connections, []() {
Log::message("\Handling EndSSR event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endssr_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endssr_event_connection;
// subscribe to the EndSSR event with a handler function keeping the connection
publisher->getEventEndSSR().connect(endssr_event_connection, endssr_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endssr_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endssr_event_connection.setEnabled(true);
// ...
// remove subscription to the EndSSR event via the connection
endssr_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndSSR event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndSSR event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSSR().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndSSR event with a handler function
publisher->getEventEndSSR().connect(endssr_event_handler);
// remove subscription to the EndSSR event later by the handler function
publisher->getEventEndSSR().disconnect(endssr_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endssr_handler_id;
// subscribe to the EndSSR event with a lambda handler function and keeping connection ID
endssr_handler_id = publisher->getEventEndSSR().connect([]() {
Log::message("\Handling EndSSR event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndSSR().disconnect(endssr_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndSSR events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSSR().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndSSR().setEnabled(true);Return value
Event reference.Event<> getEventBeginSSR() const#
event triggered before the SSR rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginSSR event handler
void beginssr_event_handler()
{
Log::message("\Handling BeginSSR event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginssr_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSSR().connect(beginssr_event_connections, beginssr_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSSR().connect(beginssr_event_connections, []() {
Log::message("\Handling BeginSSR event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginssr_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginssr_event_connection;
// subscribe to the BeginSSR event with a handler function keeping the connection
publisher->getEventBeginSSR().connect(beginssr_event_connection, beginssr_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginssr_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginssr_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginSSR event via the connection
beginssr_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginSSR event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginSSR event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSSR().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginSSR event with a handler function
publisher->getEventBeginSSR().connect(beginssr_event_handler);
// remove subscription to the BeginSSR event later by the handler function
publisher->getEventBeginSSR().disconnect(beginssr_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginssr_handler_id;
// subscribe to the BeginSSR event with a lambda handler function and keeping connection ID
beginssr_handler_id = publisher->getEventBeginSSR().connect([]() {
Log::message("\Handling BeginSSR event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginSSR().disconnect(beginssr_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginSSR events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSSR().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginSSR().setEnabled(true);Return value
Event reference.Event<> getEventEndSSSS() const#
event triggered after the Screen-Space Shadow Shafts rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndSSSS event handler
void endssss_event_handler()
{
Log::message("\Handling EndSSSS event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endssss_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSSSS().connect(endssss_event_connections, endssss_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSSSS().connect(endssss_event_connections, []() {
Log::message("\Handling EndSSSS event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endssss_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endssss_event_connection;
// subscribe to the EndSSSS event with a handler function keeping the connection
publisher->getEventEndSSSS().connect(endssss_event_connection, endssss_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endssss_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endssss_event_connection.setEnabled(true);
// ...
// remove subscription to the EndSSSS event via the connection
endssss_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndSSSS event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndSSSS event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSSSS().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndSSSS event with a handler function
publisher->getEventEndSSSS().connect(endssss_event_handler);
// remove subscription to the EndSSSS event later by the handler function
publisher->getEventEndSSSS().disconnect(endssss_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endssss_handler_id;
// subscribe to the EndSSSS event with a lambda handler function and keeping connection ID
endssss_handler_id = publisher->getEventEndSSSS().connect([]() {
Log::message("\Handling EndSSSS event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndSSSS().disconnect(endssss_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndSSSS events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSSSS().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndSSSS().setEnabled(true);Return value
Event reference.Event<> getEventBeginSSSS() const#
event triggered before the Screen-Space Shadow Shafts rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginSSSS event handler
void beginssss_event_handler()
{
Log::message("\Handling BeginSSSS event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginssss_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSSSS().connect(beginssss_event_connections, beginssss_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSSSS().connect(beginssss_event_connections, []() {
Log::message("\Handling BeginSSSS event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginssss_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginssss_event_connection;
// subscribe to the BeginSSSS event with a handler function keeping the connection
publisher->getEventBeginSSSS().connect(beginssss_event_connection, beginssss_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginssss_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginssss_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginSSSS event via the connection
beginssss_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginSSSS event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginSSSS event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSSSS().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginSSSS event with a handler function
publisher->getEventBeginSSSS().connect(beginssss_event_handler);
// remove subscription to the BeginSSSS event later by the handler function
publisher->getEventBeginSSSS().disconnect(beginssss_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginssss_handler_id;
// subscribe to the BeginSSSS event with a lambda handler function and keeping connection ID
beginssss_handler_id = publisher->getEventBeginSSSS().connect([]() {
Log::message("\Handling BeginSSSS event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginSSSS().disconnect(beginssss_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginSSSS events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSSSS().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginSSSS().setEnabled(true);Return value
Event reference.Event<> getEventEndTransparentBlurBuffer() const#
event triggered after filling the transparent blur buffer. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndTransparentBlurBuffer event handler
void endtransparentblurbuffer_event_handler()
{
Log::message("\Handling EndTransparentBlurBuffer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endtransparentblurbuffer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndTransparentBlurBuffer().connect(endtransparentblurbuffer_event_connections, endtransparentblurbuffer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndTransparentBlurBuffer().connect(endtransparentblurbuffer_event_connections, []() {
Log::message("\Handling EndTransparentBlurBuffer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endtransparentblurbuffer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endtransparentblurbuffer_event_connection;
// subscribe to the EndTransparentBlurBuffer event with a handler function keeping the connection
publisher->getEventEndTransparentBlurBuffer().connect(endtransparentblurbuffer_event_connection, endtransparentblurbuffer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endtransparentblurbuffer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endtransparentblurbuffer_event_connection.setEnabled(true);
// ...
// remove subscription to the EndTransparentBlurBuffer event via the connection
endtransparentblurbuffer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndTransparentBlurBuffer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndTransparentBlurBuffer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndTransparentBlurBuffer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndTransparentBlurBuffer event with a handler function
publisher->getEventEndTransparentBlurBuffer().connect(endtransparentblurbuffer_event_handler);
// remove subscription to the EndTransparentBlurBuffer event later by the handler function
publisher->getEventEndTransparentBlurBuffer().disconnect(endtransparentblurbuffer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endtransparentblurbuffer_handler_id;
// subscribe to the EndTransparentBlurBuffer event with a lambda handler function and keeping connection ID
endtransparentblurbuffer_handler_id = publisher->getEventEndTransparentBlurBuffer().connect([]() {
Log::message("\Handling EndTransparentBlurBuffer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndTransparentBlurBuffer().disconnect(endtransparentblurbuffer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndTransparentBlurBuffer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndTransparentBlurBuffer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndTransparentBlurBuffer().setEnabled(true);Return value
Event reference.Event<> getEventBeginTransparentBlurBuffer() const#
event triggered before filling the transparent blur buffer. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginTransparentBlurBuffer event handler
void begintransparentblurbuffer_event_handler()
{
Log::message("\Handling BeginTransparentBlurBuffer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections begintransparentblurbuffer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginTransparentBlurBuffer().connect(begintransparentblurbuffer_event_connections, begintransparentblurbuffer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginTransparentBlurBuffer().connect(begintransparentblurbuffer_event_connections, []() {
Log::message("\Handling BeginTransparentBlurBuffer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
begintransparentblurbuffer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection begintransparentblurbuffer_event_connection;
// subscribe to the BeginTransparentBlurBuffer event with a handler function keeping the connection
publisher->getEventBeginTransparentBlurBuffer().connect(begintransparentblurbuffer_event_connection, begintransparentblurbuffer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
begintransparentblurbuffer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
begintransparentblurbuffer_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginTransparentBlurBuffer event via the connection
begintransparentblurbuffer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginTransparentBlurBuffer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginTransparentBlurBuffer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginTransparentBlurBuffer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginTransparentBlurBuffer event with a handler function
publisher->getEventBeginTransparentBlurBuffer().connect(begintransparentblurbuffer_event_handler);
// remove subscription to the BeginTransparentBlurBuffer event later by the handler function
publisher->getEventBeginTransparentBlurBuffer().disconnect(begintransparentblurbuffer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId begintransparentblurbuffer_handler_id;
// subscribe to the BeginTransparentBlurBuffer event with a lambda handler function and keeping connection ID
begintransparentblurbuffer_handler_id = publisher->getEventBeginTransparentBlurBuffer().connect([]() {
Log::message("\Handling BeginTransparentBlurBuffer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginTransparentBlurBuffer().disconnect(begintransparentblurbuffer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginTransparentBlurBuffer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginTransparentBlurBuffer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginTransparentBlurBuffer().setEnabled(true);Return value
Event reference.Event<> getEventEndRefractionBuffer() const#
event triggered after filling the refraction buffer. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndRefractionBuffer event handler
void endrefractionbuffer_event_handler()
{
Log::message("\Handling EndRefractionBuffer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endrefractionbuffer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndRefractionBuffer().connect(endrefractionbuffer_event_connections, endrefractionbuffer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndRefractionBuffer().connect(endrefractionbuffer_event_connections, []() {
Log::message("\Handling EndRefractionBuffer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endrefractionbuffer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endrefractionbuffer_event_connection;
// subscribe to the EndRefractionBuffer event with a handler function keeping the connection
publisher->getEventEndRefractionBuffer().connect(endrefractionbuffer_event_connection, endrefractionbuffer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endrefractionbuffer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endrefractionbuffer_event_connection.setEnabled(true);
// ...
// remove subscription to the EndRefractionBuffer event via the connection
endrefractionbuffer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndRefractionBuffer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndRefractionBuffer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndRefractionBuffer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndRefractionBuffer event with a handler function
publisher->getEventEndRefractionBuffer().connect(endrefractionbuffer_event_handler);
// remove subscription to the EndRefractionBuffer event later by the handler function
publisher->getEventEndRefractionBuffer().disconnect(endrefractionbuffer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endrefractionbuffer_handler_id;
// subscribe to the EndRefractionBuffer event with a lambda handler function and keeping connection ID
endrefractionbuffer_handler_id = publisher->getEventEndRefractionBuffer().connect([]() {
Log::message("\Handling EndRefractionBuffer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndRefractionBuffer().disconnect(endrefractionbuffer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndRefractionBuffer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndRefractionBuffer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndRefractionBuffer().setEnabled(true);Return value
Event reference.Event<> getEventBeginRefractionBuffer() const#
event triggered before filling the refraction buffer. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginRefractionBuffer event handler
void beginrefractionbuffer_event_handler()
{
Log::message("\Handling BeginRefractionBuffer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginrefractionbuffer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginRefractionBuffer().connect(beginrefractionbuffer_event_connections, beginrefractionbuffer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginRefractionBuffer().connect(beginrefractionbuffer_event_connections, []() {
Log::message("\Handling BeginRefractionBuffer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginrefractionbuffer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginrefractionbuffer_event_connection;
// subscribe to the BeginRefractionBuffer event with a handler function keeping the connection
publisher->getEventBeginRefractionBuffer().connect(beginrefractionbuffer_event_connection, beginrefractionbuffer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginrefractionbuffer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginrefractionbuffer_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginRefractionBuffer event via the connection
beginrefractionbuffer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginRefractionBuffer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginRefractionBuffer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginRefractionBuffer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginRefractionBuffer event with a handler function
publisher->getEventBeginRefractionBuffer().connect(beginrefractionbuffer_event_handler);
// remove subscription to the BeginRefractionBuffer event later by the handler function
publisher->getEventBeginRefractionBuffer().disconnect(beginrefractionbuffer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginrefractionbuffer_handler_id;
// subscribe to the BeginRefractionBuffer event with a lambda handler function and keeping connection ID
beginrefractionbuffer_handler_id = publisher->getEventBeginRefractionBuffer().connect([]() {
Log::message("\Handling BeginRefractionBuffer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginRefractionBuffer().disconnect(beginrefractionbuffer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginRefractionBuffer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginRefractionBuffer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginRefractionBuffer().setEnabled(true);Return value
Event reference.Event<> getEventEndAuxiliaryBuffer() const#
event triggered after filling the auxiliary buffer. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndAuxiliaryBuffer event handler
void endauxiliarybuffer_event_handler()
{
Log::message("\Handling EndAuxiliaryBuffer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endauxiliarybuffer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndAuxiliaryBuffer().connect(endauxiliarybuffer_event_connections, endauxiliarybuffer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndAuxiliaryBuffer().connect(endauxiliarybuffer_event_connections, []() {
Log::message("\Handling EndAuxiliaryBuffer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endauxiliarybuffer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endauxiliarybuffer_event_connection;
// subscribe to the EndAuxiliaryBuffer event with a handler function keeping the connection
publisher->getEventEndAuxiliaryBuffer().connect(endauxiliarybuffer_event_connection, endauxiliarybuffer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endauxiliarybuffer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endauxiliarybuffer_event_connection.setEnabled(true);
// ...
// remove subscription to the EndAuxiliaryBuffer event via the connection
endauxiliarybuffer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndAuxiliaryBuffer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndAuxiliaryBuffer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndAuxiliaryBuffer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndAuxiliaryBuffer event with a handler function
publisher->getEventEndAuxiliaryBuffer().connect(endauxiliarybuffer_event_handler);
// remove subscription to the EndAuxiliaryBuffer event later by the handler function
publisher->getEventEndAuxiliaryBuffer().disconnect(endauxiliarybuffer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endauxiliarybuffer_handler_id;
// subscribe to the EndAuxiliaryBuffer event with a lambda handler function and keeping connection ID
endauxiliarybuffer_handler_id = publisher->getEventEndAuxiliaryBuffer().connect([]() {
Log::message("\Handling EndAuxiliaryBuffer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndAuxiliaryBuffer().disconnect(endauxiliarybuffer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndAuxiliaryBuffer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndAuxiliaryBuffer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndAuxiliaryBuffer().setEnabled(true);Return value
Event reference.Event<> getEventBeginAuxiliaryBuffer() const#
event triggered before filling the auxiliary buffer. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginAuxiliaryBuffer event handler
void beginauxiliarybuffer_event_handler()
{
Log::message("\Handling BeginAuxiliaryBuffer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginauxiliarybuffer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginAuxiliaryBuffer().connect(beginauxiliarybuffer_event_connections, beginauxiliarybuffer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginAuxiliaryBuffer().connect(beginauxiliarybuffer_event_connections, []() {
Log::message("\Handling BeginAuxiliaryBuffer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginauxiliarybuffer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginauxiliarybuffer_event_connection;
// subscribe to the BeginAuxiliaryBuffer event with a handler function keeping the connection
publisher->getEventBeginAuxiliaryBuffer().connect(beginauxiliarybuffer_event_connection, beginauxiliarybuffer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginauxiliarybuffer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginauxiliarybuffer_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginAuxiliaryBuffer event via the connection
beginauxiliarybuffer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginAuxiliaryBuffer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginAuxiliaryBuffer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginAuxiliaryBuffer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginAuxiliaryBuffer event with a handler function
publisher->getEventBeginAuxiliaryBuffer().connect(beginauxiliarybuffer_event_handler);
// remove subscription to the BeginAuxiliaryBuffer event later by the handler function
publisher->getEventBeginAuxiliaryBuffer().disconnect(beginauxiliarybuffer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginauxiliarybuffer_handler_id;
// subscribe to the BeginAuxiliaryBuffer event with a lambda handler function and keeping connection ID
beginauxiliarybuffer_handler_id = publisher->getEventBeginAuxiliaryBuffer().connect([]() {
Log::message("\Handling BeginAuxiliaryBuffer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginAuxiliaryBuffer().disconnect(beginauxiliarybuffer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginAuxiliaryBuffer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginAuxiliaryBuffer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginAuxiliaryBuffer().setEnabled(true);Return value
Event reference.Event<> getEventEndOpacityPlanarProbes() const#
event triggered after the opacity planar probes rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndOpacityPlanarProbes event handler
void endopacityplanarprobes_event_handler()
{
Log::message("\Handling EndOpacityPlanarProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endopacityplanarprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndOpacityPlanarProbes().connect(endopacityplanarprobes_event_connections, endopacityplanarprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndOpacityPlanarProbes().connect(endopacityplanarprobes_event_connections, []() {
Log::message("\Handling EndOpacityPlanarProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endopacityplanarprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endopacityplanarprobes_event_connection;
// subscribe to the EndOpacityPlanarProbes event with a handler function keeping the connection
publisher->getEventEndOpacityPlanarProbes().connect(endopacityplanarprobes_event_connection, endopacityplanarprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endopacityplanarprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endopacityplanarprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the EndOpacityPlanarProbes event via the connection
endopacityplanarprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndOpacityPlanarProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndOpacityPlanarProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndOpacityPlanarProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndOpacityPlanarProbes event with a handler function
publisher->getEventEndOpacityPlanarProbes().connect(endopacityplanarprobes_event_handler);
// remove subscription to the EndOpacityPlanarProbes event later by the handler function
publisher->getEventEndOpacityPlanarProbes().disconnect(endopacityplanarprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endopacityplanarprobes_handler_id;
// subscribe to the EndOpacityPlanarProbes event with a lambda handler function and keeping connection ID
endopacityplanarprobes_handler_id = publisher->getEventEndOpacityPlanarProbes().connect([]() {
Log::message("\Handling EndOpacityPlanarProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndOpacityPlanarProbes().disconnect(endopacityplanarprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndOpacityPlanarProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndOpacityPlanarProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndOpacityPlanarProbes().setEnabled(true);Return value
Event reference.Event<> getEventBeginOpacityPlanarProbes() const#
event triggered before the opacity planar probes rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginOpacityPlanarProbes event handler
void beginopacityplanarprobes_event_handler()
{
Log::message("\Handling BeginOpacityPlanarProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginopacityplanarprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginOpacityPlanarProbes().connect(beginopacityplanarprobes_event_connections, beginopacityplanarprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginOpacityPlanarProbes().connect(beginopacityplanarprobes_event_connections, []() {
Log::message("\Handling BeginOpacityPlanarProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginopacityplanarprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginopacityplanarprobes_event_connection;
// subscribe to the BeginOpacityPlanarProbes event with a handler function keeping the connection
publisher->getEventBeginOpacityPlanarProbes().connect(beginopacityplanarprobes_event_connection, beginopacityplanarprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginopacityplanarprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginopacityplanarprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginOpacityPlanarProbes event via the connection
beginopacityplanarprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginOpacityPlanarProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginOpacityPlanarProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginOpacityPlanarProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginOpacityPlanarProbes event with a handler function
publisher->getEventBeginOpacityPlanarProbes().connect(beginopacityplanarprobes_event_handler);
// remove subscription to the BeginOpacityPlanarProbes event later by the handler function
publisher->getEventBeginOpacityPlanarProbes().disconnect(beginopacityplanarprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginopacityplanarprobes_handler_id;
// subscribe to the BeginOpacityPlanarProbes event with a lambda handler function and keeping connection ID
beginopacityplanarprobes_handler_id = publisher->getEventBeginOpacityPlanarProbes().connect([]() {
Log::message("\Handling BeginOpacityPlanarProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginOpacityPlanarProbes().disconnect(beginopacityplanarprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginOpacityPlanarProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginOpacityPlanarProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginOpacityPlanarProbes().setEnabled(true);Return value
Event reference.Event<> getEventEndOpacityEnvironmentProbes() const#
event triggered after the opacity environment probes rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndOpacityEnvironmentProbes event handler
void endopacityenvironmentprobes_event_handler()
{
Log::message("\Handling EndOpacityEnvironmentProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endopacityenvironmentprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndOpacityEnvironmentProbes().connect(endopacityenvironmentprobes_event_connections, endopacityenvironmentprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndOpacityEnvironmentProbes().connect(endopacityenvironmentprobes_event_connections, []() {
Log::message("\Handling EndOpacityEnvironmentProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endopacityenvironmentprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endopacityenvironmentprobes_event_connection;
// subscribe to the EndOpacityEnvironmentProbes event with a handler function keeping the connection
publisher->getEventEndOpacityEnvironmentProbes().connect(endopacityenvironmentprobes_event_connection, endopacityenvironmentprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endopacityenvironmentprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endopacityenvironmentprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the EndOpacityEnvironmentProbes event via the connection
endopacityenvironmentprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndOpacityEnvironmentProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndOpacityEnvironmentProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndOpacityEnvironmentProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndOpacityEnvironmentProbes event with a handler function
publisher->getEventEndOpacityEnvironmentProbes().connect(endopacityenvironmentprobes_event_handler);
// remove subscription to the EndOpacityEnvironmentProbes event later by the handler function
publisher->getEventEndOpacityEnvironmentProbes().disconnect(endopacityenvironmentprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endopacityenvironmentprobes_handler_id;
// subscribe to the EndOpacityEnvironmentProbes event with a lambda handler function and keeping connection ID
endopacityenvironmentprobes_handler_id = publisher->getEventEndOpacityEnvironmentProbes().connect([]() {
Log::message("\Handling EndOpacityEnvironmentProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndOpacityEnvironmentProbes().disconnect(endopacityenvironmentprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndOpacityEnvironmentProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndOpacityEnvironmentProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndOpacityEnvironmentProbes().setEnabled(true);Return value
Event reference.Event<> getEventBeginOpacityEnvironmentProbes() const#
event triggered before the opacity environment probes rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginOpacityEnvironmentProbes event handler
void beginopacityenvironmentprobes_event_handler()
{
Log::message("\Handling BeginOpacityEnvironmentProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginopacityenvironmentprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginOpacityEnvironmentProbes().connect(beginopacityenvironmentprobes_event_connections, beginopacityenvironmentprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginOpacityEnvironmentProbes().connect(beginopacityenvironmentprobes_event_connections, []() {
Log::message("\Handling BeginOpacityEnvironmentProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginopacityenvironmentprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginopacityenvironmentprobes_event_connection;
// subscribe to the BeginOpacityEnvironmentProbes event with a handler function keeping the connection
publisher->getEventBeginOpacityEnvironmentProbes().connect(beginopacityenvironmentprobes_event_connection, beginopacityenvironmentprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginopacityenvironmentprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginopacityenvironmentprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginOpacityEnvironmentProbes event via the connection
beginopacityenvironmentprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginOpacityEnvironmentProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginOpacityEnvironmentProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginOpacityEnvironmentProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginOpacityEnvironmentProbes event with a handler function
publisher->getEventBeginOpacityEnvironmentProbes().connect(beginopacityenvironmentprobes_event_handler);
// remove subscription to the BeginOpacityEnvironmentProbes event later by the handler function
publisher->getEventBeginOpacityEnvironmentProbes().disconnect(beginopacityenvironmentprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginopacityenvironmentprobes_handler_id;
// subscribe to the BeginOpacityEnvironmentProbes event with a lambda handler function and keeping connection ID
beginopacityenvironmentprobes_handler_id = publisher->getEventBeginOpacityEnvironmentProbes().connect([]() {
Log::message("\Handling BeginOpacityEnvironmentProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginOpacityEnvironmentProbes().disconnect(beginopacityenvironmentprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginOpacityEnvironmentProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginOpacityEnvironmentProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginOpacityEnvironmentProbes().setEnabled(true);Return value
Event reference.Event<> getEventEndOpacityVoxelProbes() const#
event triggered after the opacity voxel probes rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndOpacityVoxelProbes event handler
void endopacityvoxelprobes_event_handler()
{
Log::message("\Handling EndOpacityVoxelProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endopacityvoxelprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndOpacityVoxelProbes().connect(endopacityvoxelprobes_event_connections, endopacityvoxelprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndOpacityVoxelProbes().connect(endopacityvoxelprobes_event_connections, []() {
Log::message("\Handling EndOpacityVoxelProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endopacityvoxelprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endopacityvoxelprobes_event_connection;
// subscribe to the EndOpacityVoxelProbes event with a handler function keeping the connection
publisher->getEventEndOpacityVoxelProbes().connect(endopacityvoxelprobes_event_connection, endopacityvoxelprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endopacityvoxelprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endopacityvoxelprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the EndOpacityVoxelProbes event via the connection
endopacityvoxelprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndOpacityVoxelProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndOpacityVoxelProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndOpacityVoxelProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndOpacityVoxelProbes event with a handler function
publisher->getEventEndOpacityVoxelProbes().connect(endopacityvoxelprobes_event_handler);
// remove subscription to the EndOpacityVoxelProbes event later by the handler function
publisher->getEventEndOpacityVoxelProbes().disconnect(endopacityvoxelprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endopacityvoxelprobes_handler_id;
// subscribe to the EndOpacityVoxelProbes event with a lambda handler function and keeping connection ID
endopacityvoxelprobes_handler_id = publisher->getEventEndOpacityVoxelProbes().connect([]() {
Log::message("\Handling EndOpacityVoxelProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndOpacityVoxelProbes().disconnect(endopacityvoxelprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndOpacityVoxelProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndOpacityVoxelProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndOpacityVoxelProbes().setEnabled(true);Return value
Event reference.Event<> getEventBeginOpacityVoxelProbes() const#
event triggered before the opacity voxel probes rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginOpacityVoxelProbes event handler
void beginopacityvoxelprobes_event_handler()
{
Log::message("\Handling BeginOpacityVoxelProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginopacityvoxelprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginOpacityVoxelProbes().connect(beginopacityvoxelprobes_event_connections, beginopacityvoxelprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginOpacityVoxelProbes().connect(beginopacityvoxelprobes_event_connections, []() {
Log::message("\Handling BeginOpacityVoxelProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginopacityvoxelprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginopacityvoxelprobes_event_connection;
// subscribe to the BeginOpacityVoxelProbes event with a handler function keeping the connection
publisher->getEventBeginOpacityVoxelProbes().connect(beginopacityvoxelprobes_event_connection, beginopacityvoxelprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginopacityvoxelprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginopacityvoxelprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginOpacityVoxelProbes event via the connection
beginopacityvoxelprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginOpacityVoxelProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginOpacityVoxelProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginOpacityVoxelProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginOpacityVoxelProbes event with a handler function
publisher->getEventBeginOpacityVoxelProbes().connect(beginopacityvoxelprobes_event_handler);
// remove subscription to the BeginOpacityVoxelProbes event later by the handler function
publisher->getEventBeginOpacityVoxelProbes().disconnect(beginopacityvoxelprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginopacityvoxelprobes_handler_id;
// subscribe to the BeginOpacityVoxelProbes event with a lambda handler function and keeping connection ID
beginopacityvoxelprobes_handler_id = publisher->getEventBeginOpacityVoxelProbes().connect([]() {
Log::message("\Handling BeginOpacityVoxelProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginOpacityVoxelProbes().disconnect(beginopacityvoxelprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginOpacityVoxelProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginOpacityVoxelProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginOpacityVoxelProbes().setEnabled(true);Return value
Event reference.Event<> getEventEndOpacityLights() const#
event triggered after the opacity lightgs rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndOpacityLights event handler
void endopacitylights_event_handler()
{
Log::message("\Handling EndOpacityLights event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endopacitylights_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndOpacityLights().connect(endopacitylights_event_connections, endopacitylights_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndOpacityLights().connect(endopacitylights_event_connections, []() {
Log::message("\Handling EndOpacityLights event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endopacitylights_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endopacitylights_event_connection;
// subscribe to the EndOpacityLights event with a handler function keeping the connection
publisher->getEventEndOpacityLights().connect(endopacitylights_event_connection, endopacitylights_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endopacitylights_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endopacitylights_event_connection.setEnabled(true);
// ...
// remove subscription to the EndOpacityLights event via the connection
endopacitylights_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndOpacityLights event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndOpacityLights event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndOpacityLights().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndOpacityLights event with a handler function
publisher->getEventEndOpacityLights().connect(endopacitylights_event_handler);
// remove subscription to the EndOpacityLights event later by the handler function
publisher->getEventEndOpacityLights().disconnect(endopacitylights_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endopacitylights_handler_id;
// subscribe to the EndOpacityLights event with a lambda handler function and keeping connection ID
endopacitylights_handler_id = publisher->getEventEndOpacityLights().connect([]() {
Log::message("\Handling EndOpacityLights event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndOpacityLights().disconnect(endopacitylights_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndOpacityLights events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndOpacityLights().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndOpacityLights().setEnabled(true);Return value
Event reference.Event<> getEventBeginOpacityLights() const#
event triggered before the opacity lightgs rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginOpacityLights event handler
void beginopacitylights_event_handler()
{
Log::message("\Handling BeginOpacityLights event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginopacitylights_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginOpacityLights().connect(beginopacitylights_event_connections, beginopacitylights_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginOpacityLights().connect(beginopacitylights_event_connections, []() {
Log::message("\Handling BeginOpacityLights event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginopacitylights_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginopacitylights_event_connection;
// subscribe to the BeginOpacityLights event with a handler function keeping the connection
publisher->getEventBeginOpacityLights().connect(beginopacitylights_event_connection, beginopacitylights_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginopacitylights_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginopacitylights_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginOpacityLights event via the connection
beginopacitylights_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginOpacityLights event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginOpacityLights event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginOpacityLights().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginOpacityLights event with a handler function
publisher->getEventBeginOpacityLights().connect(beginopacitylights_event_handler);
// remove subscription to the BeginOpacityLights event later by the handler function
publisher->getEventBeginOpacityLights().disconnect(beginopacitylights_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginopacitylights_handler_id;
// subscribe to the BeginOpacityLights event with a lambda handler function and keeping connection ID
beginopacitylights_handler_id = publisher->getEventBeginOpacityLights().connect([]() {
Log::message("\Handling BeginOpacityLights event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginOpacityLights().disconnect(beginopacitylights_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginOpacityLights events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginOpacityLights().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginOpacityLights().setEnabled(true);Return value
Event reference.Event<> getEventEndSSRTGI() const#
event triggered after the SSRTGI rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndSSRTGI event handler
void endssrtgi_event_handler()
{
Log::message("\Handling EndSSRTGI event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endssrtgi_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSSRTGI().connect(endssrtgi_event_connections, endssrtgi_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSSRTGI().connect(endssrtgi_event_connections, []() {
Log::message("\Handling EndSSRTGI event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endssrtgi_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endssrtgi_event_connection;
// subscribe to the EndSSRTGI event with a handler function keeping the connection
publisher->getEventEndSSRTGI().connect(endssrtgi_event_connection, endssrtgi_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endssrtgi_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endssrtgi_event_connection.setEnabled(true);
// ...
// remove subscription to the EndSSRTGI event via the connection
endssrtgi_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndSSRTGI event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndSSRTGI event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSSRTGI().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndSSRTGI event with a handler function
publisher->getEventEndSSRTGI().connect(endssrtgi_event_handler);
// remove subscription to the EndSSRTGI event later by the handler function
publisher->getEventEndSSRTGI().disconnect(endssrtgi_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endssrtgi_handler_id;
// subscribe to the EndSSRTGI event with a lambda handler function and keeping connection ID
endssrtgi_handler_id = publisher->getEventEndSSRTGI().connect([]() {
Log::message("\Handling EndSSRTGI event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndSSRTGI().disconnect(endssrtgi_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndSSRTGI events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSSRTGI().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndSSRTGI().setEnabled(true);Return value
Event reference.Event<> getEventBeginSSRTGI() const#
event triggered before the SSRTGI rendering stage. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the BeginSSRTGI event handler
void beginssrtgi_event_handler()
{
Log::message("\Handling BeginSSRTGI event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginssrtgi_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSSRTGI().connect(beginssrtgi_event_connections, beginssrtgi_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSSRTGI().connect(beginssrtgi_event_connections, []() {
Log::message("\Handling BeginSSRTGI event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginssrtgi_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginssrtgi_event_connection;
// subscribe to the BeginSSRTGI event with a handler function keeping the connection
publisher->getEventBeginSSRTGI().connect(beginssrtgi_event_connection, beginssrtgi_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginssrtgi_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginssrtgi_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginSSRTGI event via the connection
beginssrtgi_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginSSRTGI event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginSSRTGI event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSSRTGI().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginSSRTGI event with a handler function
publisher->getEventBeginSSRTGI().connect(beginssrtgi_event_handler);
// remove subscription to the BeginSSRTGI event later by the handler function
publisher->getEventBeginSSRTGI().disconnect(beginssrtgi_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginssrtgi_handler_id;
// subscribe to the BeginSSRTGI event with a lambda handler function and keeping connection ID
beginssrtgi_handler_id = publisher->getEventBeginSSRTGI().connect([]() {
Log::message("\Handling BeginSSRTGI event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginSSRTGI().disconnect(beginssrtgi_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginSSRTGI events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSSRTGI().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginSSRTGI().setEnabled(true);Return value
Event reference.Event<> getEventEndCurvatureComposite() const#
event triggered after the curvature rendering stage for the SSDirt effect. You can subscribe to events via
connect()
and unsubscribe via
disconnect(). You can also use
EventConnection
and
EventConnections
classes for convenience (see examples below).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
Usage Example
Source code (C++)
// implement the EndCurvatureComposite event handler
void endcurvaturecomposite_event_handler()
{
Log::message("\Handling EndCurvatureComposite event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endcurvaturecomposite_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndCurvatureComposite().connect(endcurvaturecomposite_event_connections, endcurvaturecomposite_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndCurvatureComposite().connect(endcurvaturecomposite_event_connections, []() {
Log::message("\Handling EndCurvatureComposite event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endcurvaturecomposite_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endcurvaturecomposite_event_connection;
// subscribe to the EndCurvatureComposite event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the EndCurvatureComposite event with a handler function
publisher->getEventEndCurvatureComposite().connect(endcurvaturecomposite_event_handler);
// remove subscription to the EndCurvatureComposite event later by the handler function
publisher->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 to the EndCurvatureComposite event with a lambda handler function and keeping connection ID
endcurvaturecomposite_handler_id = publisher->getEventEndCurvatureComposite().connect([]() {
Log::message("\Handling EndCurvatureComposite event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventEndCurvatureComposite().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndCurvatureComposite().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventBeginCurvatureComposite().connect(begincurvaturecomposite_event_connections, begincurvaturecomposite_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the BeginCurvatureComposite event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the BeginCurvatureComposite event with a handler function
publisher->getEventBeginCurvatureComposite().connect(begincurvaturecomposite_event_handler);
// remove subscription to the BeginCurvatureComposite event later by the handler function
publisher->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 to the BeginCurvatureComposite event with a lambda handler function and keeping connection ID
begincurvaturecomposite_handler_id = publisher->getEventBeginCurvatureComposite().connect([]() {
Log::message("\Handling BeginCurvatureComposite event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventBeginCurvatureComposite().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginCurvatureComposite().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventEndCurvature().connect(endcurvature_event_connections, endcurvature_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the EndCurvature event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the EndCurvature event with a handler function
publisher->getEventEndCurvature().connect(endcurvature_event_handler);
// remove subscription to the EndCurvature event later by the handler function
publisher->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 to the EndCurvature event with a lambda handler function and keeping connection ID
endcurvature_handler_id = publisher->getEventEndCurvature().connect([]() {
Log::message("\Handling EndCurvature event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventEndCurvature().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndCurvature().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventBeginCurvature().connect(begincurvature_event_connections, begincurvature_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the BeginCurvature event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the BeginCurvature event with a handler function
publisher->getEventBeginCurvature().connect(begincurvature_event_handler);
// remove subscription to the BeginCurvature event later by the handler function
publisher->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 to the BeginCurvature event with a lambda handler function and keeping connection ID
begincurvature_handler_id = publisher->getEventBeginCurvature().connect([]() {
Log::message("\Handling BeginCurvature event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventBeginCurvature().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginCurvature().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventEndOpacityDecals().connect(endopacitydecals_event_connections, endopacitydecals_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the EndOpacityDecals event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the EndOpacityDecals event with a handler function
publisher->getEventEndOpacityDecals().connect(endopacitydecals_event_handler);
// remove subscription to the EndOpacityDecals event later by the handler function
publisher->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 to the EndOpacityDecals event with a lambda handler function and keeping connection ID
endopacitydecals_handler_id = publisher->getEventEndOpacityDecals().connect([]() {
Log::message("\Handling EndOpacityDecals event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventEndOpacityDecals().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndOpacityDecals().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventBeginOpacityDecals().connect(beginopacitydecals_event_connections, beginopacitydecals_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the BeginOpacityDecals event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the BeginOpacityDecals event with a handler function
publisher->getEventBeginOpacityDecals().connect(beginopacitydecals_event_handler);
// remove subscription to the BeginOpacityDecals event later by the handler function
publisher->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 to the BeginOpacityDecals event with a lambda handler function and keeping connection ID
beginopacitydecals_handler_id = publisher->getEventBeginOpacityDecals().connect([]() {
Log::message("\Handling BeginOpacityDecals event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventBeginOpacityDecals().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginOpacityDecals().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventEndOpacityGBuffer().connect(endopacitygbuffer_event_connections, endopacitygbuffer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the EndOpacityGBuffer event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the EndOpacityGBuffer event with a handler function
publisher->getEventEndOpacityGBuffer().connect(endopacitygbuffer_event_handler);
// remove subscription to the EndOpacityGBuffer event later by the handler function
publisher->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 to the EndOpacityGBuffer event with a lambda handler function and keeping connection ID
endopacitygbuffer_handler_id = publisher->getEventEndOpacityGBuffer().connect([]() {
Log::message("\Handling EndOpacityGBuffer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventEndOpacityGBuffer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndOpacityGBuffer().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventBeginOpacityGBuffer().connect(beginopacitygbuffer_event_connections, beginopacitygbuffer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the BeginOpacityGBuffer event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the BeginOpacityGBuffer event with a handler function
publisher->getEventBeginOpacityGBuffer().connect(beginopacitygbuffer_event_handler);
// remove subscription to the BeginOpacityGBuffer event later by the handler function
publisher->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 to the BeginOpacityGBuffer event with a lambda handler function and keeping connection ID
beginopacitygbuffer_handler_id = publisher->getEventBeginOpacityGBuffer().connect([]() {
Log::message("\Handling BeginOpacityGBuffer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventBeginOpacityGBuffer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginOpacityGBuffer().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventEndMixedRealityBlendMaskColor().connect(endmixedrealityblendmaskcolor_event_connections, endmixedrealityblendmaskcolor_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the EndMixedRealityBlendMaskColor event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the EndMixedRealityBlendMaskColor event with a handler function
publisher->getEventEndMixedRealityBlendMaskColor().connect(endmixedrealityblendmaskcolor_event_handler);
// remove subscription to the EndMixedRealityBlendMaskColor event later by the handler function
publisher->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 to the EndMixedRealityBlendMaskColor event with a lambda handler function and keeping connection ID
endmixedrealityblendmaskcolor_handler_id = publisher->getEventEndMixedRealityBlendMaskColor().connect([]() {
Log::message("\Handling EndMixedRealityBlendMaskColor event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventEndMixedRealityBlendMaskColor().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndMixedRealityBlendMaskColor().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventBeginMixedRealityBlendMaskColor().connect(beginmixedrealityblendmaskcolor_event_connections, beginmixedrealityblendmaskcolor_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the BeginMixedRealityBlendMaskColor event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the BeginMixedRealityBlendMaskColor event with a handler function
publisher->getEventBeginMixedRealityBlendMaskColor().connect(beginmixedrealityblendmaskcolor_event_handler);
// remove subscription to the BeginMixedRealityBlendMaskColor event later by the handler function
publisher->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 to the BeginMixedRealityBlendMaskColor event with a lambda handler function and keeping connection ID
beginmixedrealityblendmaskcolor_handler_id = publisher->getEventBeginMixedRealityBlendMaskColor().connect([]() {
Log::message("\Handling BeginMixedRealityBlendMaskColor event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventBeginMixedRealityBlendMaskColor().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginMixedRealityBlendMaskColor().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventBeginScreen().connect(beginscreen_event_connections, beginscreen_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the BeginScreen event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the BeginScreen event with a handler function
publisher->getEventBeginScreen().connect(beginscreen_event_handler);
// remove subscription to the BeginScreen event later by the handler function
publisher->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 to the BeginScreen event with a lambda handler function and keeping connection ID
beginscreen_handler_id = publisher->getEventBeginScreen().connect([]() {
Log::message("\Handling BeginScreen event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventBeginScreen().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginScreen().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventEndShadows().connect(endshadows_event_connections, endshadows_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the EndShadows event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the EndShadows event with a handler function
publisher->getEventEndShadows().connect(endshadows_event_handler);
// remove subscription to the EndShadows event later by the handler function
publisher->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 to the EndShadows event with a lambda handler function and keeping connection ID
endshadows_handler_id = publisher->getEventEndShadows().connect([]() {
Log::message("\Handling EndShadows event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventEndShadows().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndShadows().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventEndOmniShadow().connect(endomnishadow_event_connections, endomnishadow_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the EndOmniShadow event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the EndOmniShadow event with a handler function
publisher->getEventEndOmniShadow().connect(endomnishadow_event_handler);
// remove subscription to the EndOmniShadow event later by the handler function
publisher->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 to the EndOmniShadow event with a lambda handler function and keeping connection ID
endomnishadow_handler_id = publisher->getEventEndOmniShadow().connect([]() {
Log::message("\Handling EndOmniShadow event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventEndOmniShadow().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndOmniShadow().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventBeginOmniShadow().connect(beginomnishadow_event_connections, beginomnishadow_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the BeginOmniShadow event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the BeginOmniShadow event with a handler function
publisher->getEventBeginOmniShadow().connect(beginomnishadow_event_handler);
// remove subscription to the BeginOmniShadow event later by the handler function
publisher->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 to the BeginOmniShadow event with a lambda handler function and keeping connection ID
beginomnishadow_handler_id = publisher->getEventBeginOmniShadow().connect([]() {
Log::message("\Handling BeginOmniShadow event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventBeginOmniShadow().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginOmniShadow().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventEndProjShadow().connect(endprojshadow_event_connections, endprojshadow_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the EndProjShadow event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the EndProjShadow event with a handler function
publisher->getEventEndProjShadow().connect(endprojshadow_event_handler);
// remove subscription to the EndProjShadow event later by the handler function
publisher->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 to the EndProjShadow event with a lambda handler function and keeping connection ID
endprojshadow_handler_id = publisher->getEventEndProjShadow().connect([]() {
Log::message("\Handling EndProjShadow event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventEndProjShadow().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndProjShadow().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventBeginProjShadow().connect(beginprojshadow_event_connections, beginprojshadow_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the BeginProjShadow event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the BeginProjShadow event with a handler function
publisher->getEventBeginProjShadow().connect(beginprojshadow_event_handler);
// remove subscription to the BeginProjShadow event later by the handler function
publisher->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 to the BeginProjShadow event with a lambda handler function and keeping connection ID
beginprojshadow_handler_id = publisher->getEventBeginProjShadow().connect([]() {
Log::message("\Handling BeginProjShadow event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventBeginProjShadow().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginProjShadow().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventEndWorldShadow().connect(endworldshadow_event_connections, endworldshadow_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the EndWorldShadow event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the EndWorldShadow event with a handler function
publisher->getEventEndWorldShadow().connect(endworldshadow_event_handler);
// remove subscription to the EndWorldShadow event later by the handler function
publisher->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 to the EndWorldShadow event with a lambda handler function and keeping connection ID
endworldshadow_handler_id = publisher->getEventEndWorldShadow().connect([]() {
Log::message("\Handling EndWorldShadow event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventEndWorldShadow().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndWorldShadow().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventBeginWorldShadow().connect(beginworldshadow_event_connections, beginworldshadow_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the BeginWorldShadow event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the BeginWorldShadow event with a handler function
publisher->getEventBeginWorldShadow().connect(beginworldshadow_event_handler);
// remove subscription to the BeginWorldShadow event later by the handler function
publisher->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 to the BeginWorldShadow event with a lambda handler function and keeping connection ID
beginworldshadow_handler_id = publisher->getEventBeginWorldShadow().connect([]() {
Log::message("\Handling BeginWorldShadow event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventBeginWorldShadow().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginWorldShadow().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventBeginShadows().connect(beginshadows_event_connections, beginshadows_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the BeginShadows event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the BeginShadows event with a handler function
publisher->getEventBeginShadows().connect(beginshadows_event_handler);
// remove subscription to the BeginShadows event later by the handler function
publisher->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 to the BeginShadows event with a lambda handler function and keeping connection ID
beginshadows_handler_id = publisher->getEventBeginShadows().connect([]() {
Log::message("\Handling BeginShadows event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventBeginShadows().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginShadows().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventEndEnvironment().connect(endenvironment_event_connections, endenvironment_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the EndEnvironment event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the EndEnvironment event with a handler function
publisher->getEventEndEnvironment().connect(endenvironment_event_handler);
// remove subscription to the EndEnvironment event later by the handler function
publisher->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 to the EndEnvironment event with a lambda handler function and keeping connection ID
endenvironment_handler_id = publisher->getEventEndEnvironment().connect([]() {
Log::message("\Handling EndEnvironment event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventEndEnvironment().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndEnvironment().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventBeginEnvironment().connect(beginenvironment_event_connections, beginenvironment_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the BeginEnvironment event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the BeginEnvironment event with a handler function
publisher->getEventBeginEnvironment().connect(beginenvironment_event_handler);
// remove subscription to the BeginEnvironment event later by the handler function
publisher->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 to the BeginEnvironment event with a lambda handler function and keeping connection ID
beginenvironment_handler_id = publisher->getEventBeginEnvironment().connect([]() {
Log::message("\Handling BeginEnvironment event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventBeginEnvironment().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginEnvironment().setEnabled(true);Return value
Event reference.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).
The event handler signature is as follows: myhandler(Notice
For more details see the Event Handling article.
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 to an event (subscription to various events can be linked)
publisher->getEventBegin().connect(begin_event_connections, begin_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->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 to the Begin event with a handler function keeping the connection
publisher->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 to 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
publisher->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 to the Begin event with a handler function
publisher->getEventBegin().connect(begin_event_handler);
// remove subscription to the Begin event later by the handler function
publisher->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 to the Begin event with a lambda handler function and keeping connection ID
begin_handler_id = publisher->getEventBegin().connect([]() {
Log::message("\Handling Begin event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->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
publisher->getEventBegin().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBegin().setEnabled(true);Return value
Event reference.static ViewportPtr create ( ) #
Creates a new viewport with default settings.void appendSkipFlags ( int flags ) #
Appends specified skip flags to the list of currently used ones.Arguments
- int flags - Skip flags to append.
int checkSkipFlags ( int flags ) #
Returns a value indicating if the specified skip flags are set for the current viewport.Arguments
- int flags - Skip flags to check.
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
- int flags - Skip flags to remove.
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
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
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.
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.
- 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.
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.
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
Requires render_stereo_hidden_area = 2
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 VRvoid 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 resetEnvironmentTexture ( ) #
Resets the current environment texture to the default one.void renderVREngine ( ) #
Renders the VR viewport if VR is enabled, taking into account the vr mirror mode set.Last update:
19.04.2024
Помогите сделать статью лучше
Была ли эта статья полезной?
(или выберите слово/фразу и нажмите Ctrl+Enter