Overview

OpenFlipper data types consist of several components.

The underlying data type (like OpenMesh or a class or simply an array of points)
The rendering node that is used to display the data
The Object class which manages your data and rendering inside OpenFlipper

Furthermore some plugins need to be added:

A Type plugin that registers your type inside OpenFlipper and creates raw objects of your new type
Possible file plugins to read or write data to disk

File structure inside the ObjectTypes directory

For this documentation we take the Plane data type as an example.

Data storage type

The underlying data type is a simple class representing a plane. It is defined in the files "PlaneType.(hh/cc)". The type could also be defined in an extra lib outside of OpenFlipper if it is more complex (e.g. OpenMesh, CGAL,...). But for smaller types they should be inside the ObjectType directory.

Rendering nodes

The second set of files is the rendering node. The node usually takes a reference to the data type and renders the data via OpenGL. For the PointNode the implementation can be found in "PlaneNode.(hh/cc)".

Base type file

The required types are than collected in one types file which is called "PlaneTypes.hh". This file includes the nodes used for rendering and the underlying data type. Here you can add additional typedefs (e.g. if the original type would be called "planeDataType" you can typedef it to a simple "plane") to make the code more readable.

#include <ObjectTypes/Plane/PlaneType.hh>

#include <ObjectTypes/Plane/PlaneNode.hh>

Object Type

After the rendering and storage are defined, the actual object has to be implemented. This is done in the files "PlaneObject.(hh/cc)". The ObjectType has to be derived from BaseObjectData (if it will be rendered) or if there are no rendering nodes for that type and it is simply a storage it is derived from BaseObject. The ObjectType creates an instances of the data (in this case the plane) and the required rendering nodes. Additionally it has a function to copy the object, and handles the picking translation.

PluginFunctions File

The last block of files are "PluginFunctions.(hh/cc)". In these files the plugin functions for your type are implemented. They typically contain dynamic casts from the BaseObject Type to your type and node. They are used in the plugins to quickly convert between the management base class and the real data objects.

Final Include File

Finally one include file has to be created that Defines the name that is used in OpenFlipper:

#define DATA_PLANE typeId("Plane")

and includes the pluginfunctions ,object and type header:

#include <ObjectTypes/Plane/PlaneObject.hh>
#include <ObjectTypes/Plane/PluginFunctionsPlane.hh>
#include <ObjectTypes/Plane/PlaneTypes.hh>

The Type plugin

After fully defining the data type, we need to create a plugin that manages the new type inside OpenFlipper. The TypePlugin implements the TypeInterface (Type Interface ). The plugin will register the type in the OpenFlipper core. Additionally the plugin will be used to generate new objects of your type.

The File Plugins

File plugins load data from a file into your object (or save from object to file). You can write your own custom file plugins. Please look at the FileInterface for further details (File Interface ).