OGRE: Ogre::Plugin Class Reference - OGRE Documentation

Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

# Ogre::Plugin Class Reference

Class defining a generic OGRE plugin. More...

`#include <OgrePlugin.h>`

List of all members.

## Public Member Functions

| Plugin ()
virtual | ~Plugin ()
virtual const String & | getName () const =0
| Get the name of the plugin.
virtual void | install ()=0
| Perform the plugin initial installation sequence.
virtual void | initialise ()=0
| Perform any tasks the plugin needs to perform on full system initialisation.
virtual void | shutdown ()=0
| Perform any tasks the plugin needs to perform when the system is shut down.
virtual void | uninstall ()=0
| Perform the final plugin uninstallation sequence.

## Detailed Description

Class defining a generic OGRE plugin.

Remarks:
  OGRE is very plugin-oriented and you can customise much of its behaviour by registering new plugins, dynamically if you are using dynamic linking. This class abstracts the generic interface that all plugins must support. Within the implementations of this interface, the plugin must call other OGRE classes in order to register the detailed customisations it is providing, e.g. registering a new SceneManagerFactory, a new MovableObjectFactory, or a new RenderSystem.

  Plugins can be linked statically or dynamically. If they are linked dynamically (ie the plugin is in a DLL or Shared Object file), then you load the plugin by calling the Root::loadPlugin method (or some other mechanism which leads to that call, e.g. plugins.cfg), passing the name of the DLL. OGRE will then call a global init function on that DLL, and it will be expected to register one or more Plugin implementations using Root::installPlugin. The procedure is very similar if you use a static linked plugin, except that you simply instantiate the Plugin implementation yourself and pass it to Root::installPlugin.

Note:
  Lifecycle of a Plugin instance is very important. The Plugin instance must remain valid until the Plugin is uninstalled. Here are the things you must bear in mind:
  - If your plugin is in a DLL:
    - Create the Plugin instance and call Root::installPlugin in dllStartPlugin
    - Call Root::uninstallPlugin, then delete it in dllStopPlugin
  - If your plugin is statically linked in your app:
    - Create the Plugin anytime you like
    - Call Root::installPlugin any time whilst Root is valid
    - Call Root::uninstallPlugin if you like so long as Root is valid. However, it will be done for you when Root is destroyed, so the Plugin instance must still be valid at that point if you haven't manually uninstalled it.
  The install and unninstall methods will be called when the plugin is installed or uninstalled. The initialise and shutdown will be called when there is a system initialisation or shutdown, e.g. when Root::initialise or Root::shutdown are called.

Definition at line 74 of file OgrePlugin.h.

## Constructor & Destructor Documentation

Ogre::Plugin::Plugin | ( |  | ) |

| Definition at line 77 of file OgrePlugin.h.

virtual Ogre::Plugin::~Plugin | ( |  | ) | `[virtual]`

| Definition at line 78 of file OgrePlugin.h.

## Member Function Documentation

virtual const String& Ogre::Plugin::getName | ( |  | ) | const`[pure virtual]`

Get the name of the plugin.

Remarks:
  An implementation must be supplied for this method to uniquely identify the plugin.

virtual void Ogre::Plugin::initialise | ( |  | ) | `[pure virtual]`

Perform any tasks the plugin needs to perform on full system initialisation.

Remarks:
  An implementation must be supplied for this method. It is called just after the system is fully initialised (either after Root::initialise if a window is created then, or after the frist window is created) and therefore all rendersystem functionality is available at this time. You can use this hook to create any resources which are dependent on a rendersystem or have rendersystem-specific implementations.

virtual void Ogre::Plugin::install | ( |  | ) | `[pure virtual]`

Perform the plugin initial installation sequence.

Remarks:
  An implementation must be supplied for this method. It must perform the startup tasks necessary to install any rendersystem customisations or anything else that is not dependent on system initialisation, ie only dependent on the core of Ogre. It must not perform any operations that would create rendersystem-specific objects at this stage, that should be done in initialise().

virtual void Ogre::Plugin::shutdown | ( |  | ) | `[pure virtual]`

Perform any tasks the plugin needs to perform when the system is shut down.

Remarks:
  An implementation must be supplied for this method. This method is called just before key parts of the system are unloaded, such as rendersystems being shut down. You should use this hook to free up resources and decouple custom objects from the OGRE system, whilst all the instances of other plugins (e.g. rendersystems) still exist.

virtual void Ogre::Plugin::uninstall | ( |  | ) | `[pure virtual]`

Perform the final plugin uninstallation sequence.

Remarks:
  An implementation must be supplied for this method. It must perform the cleanup tasks which haven't already been performed in shutdown() (e.g. final deletion of custom instances, if you kept them around incase the system was reinitialised). At this stage you cannot be sure what other plugins are still loaded or active. It must therefore not perform any operations that would reference any rendersystem-specific objects - those should have been sorted out in the 'shutdown' method.

The documentation for this class was generated from the following file:

- OgrePlugin.h

Copyright © 2000-2005 by The OGRE Team
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Thu Mar 6 09:47:51 2008