Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

CIdentifier	Globally used identifiaction class This class is the basic class to use in order to identify objects in the OpenViBE platform. It can be used for class identification, for object identification and any user needed identification process
CIdentifier	Base class to work with EBML identifiers
CIdentifier	Base class to work with Automaton identifiers
CMatrix	Basic standalone OpenViBE matrix implementation This class offers a basic standalone impementation of the OpenViBE::IMatrix interface. This class can be directly instanciated and used
CMemoryBuffer	Basic standalone OpenViBE memory buffer implementation This class offers a basic standalone impementation of the OpenViBE::IMemoryBuffer interface. This class can be directly instanciated and used
CNameValuePairList	This class handles a list of name/value pairs. It handles a (hidden) map associating string keys to string values. This class avoids the need to include stl's map header file in the C++ interface, thus preventing potential compile/link errors when dynamically loading modules
COgreObject	An OgreObject manages a 3D object in an Ogre scene
COgreResourceGroup	Ogre Resource Group management This class handles a resource group, possibly shared by multiple scenarios. Its reference count keeps track of when it is actually needed. Resources are freed when the count reaches 0
COgreScene	Management of an Ogre scene This class creates a scene manager and a default 3D scene which can be populated using a simplified 3D API
COgreVisualisation	High level Ogre initialisation & management This class initializes the Ogre library, creates 3D scenes, windows (views of 3D scenes) and objects that populate such scenes
COgreWindow	An OgreWindow visualises a 3D scene This class manages a RenderWindow which contents are visualised in a single viewport
CStimulationSet	Basic standalone OpenViBE stimulation set implementation This class offers a basic standalone impementation of the OpenViBE::IStimulationSet interface. This class can be directly instanciated and used
CString	String class to avoid std::string in the interface This class helps avoiding std::string being present in exposed C++ interface, eventually resulting in compile/link errors when dynamically loading modules
CVisualisationContext	Visualisation context made available to plugins and allowing them to interact with a 3D scene This class offers a simplified, library independent 3D API to be used by plugin developers
GtkOVCustom	Custom Gtk widget whose behaviour may be adapted to the developer's needs This widget is to be instanciated using the gtk_ov_custom_new function only
IAlgorithm	Abstract algorithm, base element of OpenViBE processing objects This class should be derived by any plugin that is related to data processing. It basically has a parameterable interface contained in the IAlgorithmContext object. This interface stores several typed parameters which can be modified either by outside world in order to provide input paramters to this algorithm or by this algorithm itself in order to produce output parameters
IAlgorithmContext	Exectution context for algorithm objects
IAlgorithmDesc	Algorithm plugin descriptor This class should be derived by any plugin developper in order to describe a specific OpenViBE algorithm
IAlgorithmManager	Manager for all kind of plugin algorithms
IAlgorithmProto	Prototype interface for algorithm
IAlgorithmProxy	Application interface to an algorithm plugin
IAttributable
IBox	Complete OpenViBE box interface This interface can be used in order to fully describe an OpenViBE black box. It describes its identification values, its inputs, its outputs and its settings
IBoxAlgorithm	Algorithm to create/process/transform OpenViBE data This class should be derived by any plugin that is related to data processing. It can be data acquisition/production from an hardware device or from a file. It can be data processing/transforming, moving time information into frequency space for example. It can be data classification generating discrete classification events better than continuous data flow
IBoxAlgorithmContext	Specific context to use for box algorithm plugins This 'context' is given by the player to an algorithm plugin so it has all the necessary tools to work. This algorithm context mainly consists in getting other contexts which could be defined and used more generically (such as the box interface or a global player interface for example)
IBoxAlgorithmDesc	Box algorithm plugin descriptor This class should be derived by any plugin developper in order to describe a specific OpenViBE box algorithm
IBoxIO	Main OpenViBE box interface to communicate with the kernel This context allows the object which uses it to check inputs states, read them, write outputs while being in a dynamic context (used by player)
IBoxListenerContext	Exectution context for box algorithm descriptors
IBoxProto	OpenViBE box prototype This class is used by a plugin algorithm descriptor to let the OpenViBE platform know what an algorithm box looks like. It declares several things, like it input types, output types and settings
IConfigurable	Configurable object interface
IDriver	Base class for all the OpenViBE acquisition server drivers
IDriverCallback	Base class for all the OpenViBE acquisition server driver callbacks
IHeader	Base class for an OpenViBE header container
IKernelContext	Kernel context interface, gives access to each manager the kernel owns
IKernelDesc	A kernel description
IKernelLoader	This class allows an OpenViBE application to load a kernel module
IKernelObject	Base class for all kernel objects
IKernelObjectFactory	Kernel object factory, creates all kernel objects
ILink	Link information between OpenViBE box This class collects informations between OpenViBE boxes : box identifiers and input / output indices
ILogListener	Log manager's listener interface
ILogManager	Log manager
IMaterialPassAction	A class which calls the action for each pass of each technique
IMatrix	Basic OpenViBE matrix interface
IMemoryBuffer	Basic OpenViBE memory buffer interface
IMessage	Base message class
IMessageClock	Clock message
IMessageEvent	Event message
IMessageSignal	Signal message
IObject	Base class for all the OpenViBE platform objects
IObjectVisitorContext	Exectution context for visitor objects
IParameter	Generic parameter handler for configurable objects
IPlayer	The main player class A player is responsible for the playback of a specific scenario. This player scenario is provided at initialisation stage and should not be changed until the player terminates. The player idea of calling a "play" function forces the use of threads in order to avoid CPU locking. Thus we prefer the idea of having a "short-time" function that is to be called repeatedly until the player terminates. This is the role of the IPlayer::loop function, that should be called repeatedly by the outside application
IPlayerContext	Player interface for plugin objects Instances of this class are given to plugin object so they can communicate with the platform kernel, providing services such as message sending etc..
IPlayerManager	The manager responsible for scenario playback The player manager is responsible for creating the different player instances. Each player is responsible for the playback of a specific scenario
IPluginManager	Log manager
IPluginModule	Plugin module
IPluginModuleContext	Plugin context
IPluginObject	Base class for plugin object This class is the base class for all the concrete plugin classes that extend the OpenViBE platform. It comes with several basic functions each plugin should have in order to work in the OpenViBE platform
IPluginObjectDesc	Base class for plugin descriptor This class is the base class for all the plugin description classes. It contains basic functions that could be used for each plugin description. Derived plugin descriptions will be used as a prototype of what they can create
IProcessingUnit	Processing unit information for OpenViBE boxes
IReader	EBML processing class
IReaderCallback	Callback class to use when parsing the EBML stream
IReaderHelper	Helper to read basic EBML types
IScenario	A static OpenViBE scenario This class is a static scenario description. It is used to manipulate an OpenViBE box/connection collection..
IScenarioManager	The scenario manager This manager is responsible to organize and handle all the scenarios of the kernel
IsProgrammable	Action to know if is programmable. Main pass is programmable ? ie includes either a vertex or fragment program
IStimulationSet	Basic OpenViBE stimulation set interface
ITreeViewCB	Tree view interface It must be implemented by classes which communicate with the IVisualisationTree class in order to display the contents of the visualisation tree
ITypeManager	Type manager, provides information on platform's handled types, parameters, streams etc..
IVisualisationContext	Visualisation manager interface for plugin objects
IVisualisationManager	The VisualisationManager handles IVisualisationTree objects It maintains a list of IVisualisationTree objects, each of which is associated to a scenario. This manager is used both at scenario creation time (to load or create IVisualisationTree objects), and when the scenario is being run (to forward IVisualisationWidget pointers to the related IVisualisationTree)
IVisualisationManager::IVisualisationTreeEnum	An interface used to iteratively notify its creator of the existence of IVisualisationTree objects
IVisualisationTree	Handles visualisation widgets and their arrangement in space This interface lets applications configure visualisation widgets by adding them to windows and tabs, positioning them next to each other using paned widgets, and resizing them as the user sees fit. All widgets are saved in a symbolic way as IVisualisationWidget instances referenced in a tree store. Methods of this class are essentially meant to be called from an external class inheriting from the ITreeViewCB interface, for offline design or online use of the widgets
IVisualisationWidget	Interface of visualisation widgets that are handled by an IVisualisationTree These objects are stored in an IVisualisationTree object as they are being created and modified to suit the graphical needs of a scenario
IWriter	EBML formating class
IWriterCallback	Callback class to use when creating the EBML stream
IWriterHelper	Helper to write basic EBML types
MaterialSetAwareness	Action to set the awareness color. Carefull MaterialSetAwareness is exclusive, you have to choose beetween, MaterialSetMaterialName and MaterialSetAwareness
MaterialSetDiffuse	Action to set the diffuse color. Sets the color
MaterialSetMaterialName
MaterialSetSceneBlending	Action to set the scene blending. Sets the blending method to use to adjust transparency
MaterialSetShader	Action to set shader. Allow user to add fragment and shader on a new Pass
MaterialSetTransparency	Action to change this instance transparency
MaterialVertexBuffer	Action to modify a Vertex Buffer
TParameterHandler	Helper class in order to manipulate IParameter and IParameter values natively