The OpenSceneGraph is an Open Source (LGPL), Cross Platform (Windows, Linux, Mac OSX, FreeBSD, Irix, Solaris), Standard C++ and OpenGL based graphics development library. Uses range from visual simulation, games, virtual reality, scientific visualization and graphics research. This page introduces what scene graphs are, why graphics developers use them, and details about the OpenSceneGraph project, how to learn how to use it and contribute to the OpenSceneGraph community.
Robert Osfield, Project Lead. July 2002.
A scene graph isn't a complete game or simulation engine, although it may
be one of the main components of such an engine; it's primary focus is
representation of your 3d worlds, and efficient rendering thereof. Physics models,
collision detection and audio are left to other development libraries that
a user will integrate with. The fact that scene graphs don't typically
integrate all these features is actually a really good thing: it aids interoprability
with clients' own applications and tools and allows them to serve many varied
markets from games, visual simulation, virtual reality,
scientific and commercial visualization, training through to modeling programs.
Productivity - scene graphs take away much of the hard work required to develop high performance graphics applications. The scene graph manages all the graphics for you, reducing what would be thousands of lines of OpenGL down to a few simple calls. Furthermore, one of most powerful concepts in Object Oriented programming is that of object composition, enshrined in the Composite Design Pattern, which fits the scene graph tree structure perfectly and makes it a highly flexible and reusable design - in real terms this means that it can be easily adapted to solve your problems. With scene graphs often also come additional utility libraries which range from helping users set up and manage graphics windows to importing of 3d models and images. All this together allows the user to achieve a great deal with very little coding. A dozen lines of code can be enough to load your data and create an interactive viewer!
Portability - scene graphs encapsulate much of the lower level tasks of rendering graphics and reading and writing data, reducing or even eradicating the platform specific coding that you require in your own application. If the underlying scene graph is portable then moving from platform to platform can be as simple as recompiling your source code.
Scalability - along with being able to dynamic manage the complexity of scenes automatically to account for differences in graphics performance across a range of machines, scene graphs also make it much easier to manage complex hardware configurations, such as clusters of graphics machines, or multiprocessor/multipipe systems such as SGI's Onyx. A good scene graph will allow the developer to concentrate on developing their own application while the rendering framework of the scene graph handles the different underlying hardware configurations.
Productivity - by combining lessons learned from established scene graphs like Performer and Open Inventor, with modern software engineering boosts like Design Patterns, along with a great deal of feedback early on in the development cycle, it has been possible to design a library that is clean and highly interpretable. This has made it easy for users to adopt to the OpenSceneGraph and to integrate it with their own applications. With a full feature set in the core scene graph, utilities to set up the scene graph and viewers and a wide range of loaders it is possible to create an application and bring in user data with a very small amount of code.
Portability - The core scene graph has also been designed to have minimal dependency on any specific platform, requiring little more than Standard C++ and OpenGL. This has allowed the scene graph to be rapidly ported to a wide range of platforms - originally developed on IRIX, then ported to Linux, then to Windows, then FreeBSD, then Mac OSX and most recently Solaris! Being completely windowing system independent makes it easy for users to add their own window-specific libraries and applications on top. In the distribution there is already the osgProducer library, and in the Bazaar found at openscenegrph.org/download/ one can find examples of applications written on top of Qt, MFC, WxWindows and SDL. Users have also integrated it with Motif, and X.
Scalability - the scene graph will not only run on portables all the way up to Onyx Infinite Reality Monsters, it supports the multiple graphics subsystems found on machines like a mulitpipe Onyx. This is possible because the core scene graph supports multiple graphics contexts for both OpenGL Display Lists and texture objects, and the cull and draw traversals have been designed to cache rendering data locally and use the scene graph almost entirely as a read-only operation. This allows multiple cull-draw pairs to run on multiple CPU's which are bound to multiple graphics subsystems. Support for multiple graphic context and multi-threading is all available out of the box via osgProducer - all the examples in the distribution can run multi-pipe just by use a simple configuation file.
The project is currently in beta, which means the main core features are now in
place, with a 1.0 release in second half of 2003. Despite the beta development status,
the project has already earned the reputation the leading open source scene
graph, and is establishing itself as a viable alternative to the commercial
scene graphs. Numerous companies, university researchers and graphics enthusiasts
have already adopted the OpenSceneGraph for their projects, all over the world.
The binary distribution contains just the libraries (.dll's /.so's) and demo executables. This is suitable for using the OpenSceneGraph with an application that has already been compiled but depends at runtime on the OpenSceneGraph.
The development distribution contains the libraries (.dll's /.so's), demo executables, include files, and source to the demos. This is suitable for using the developers using the OpenSceneGraph.
The source distribution contains all the source and include files required to build the OpenSceneGraph from scratch, and is ideal if you want to learn more about how the scene graph works, how to extend it, and to track down and fix any problems that you come across.
If you are using a source distribution then read the installation instructions for how to get the OpenSceneGraph compiling and installed on your system. You may also need to download libraries that parts of the OpenSceneGraph depend upon, such as Producer. Check the dependencies list for further details.
For full instructions of how to run the examples read the examples
A programming guide will be available in form of a OpenSceneGraph book which is being written by Don Burns and Robert Osfield, parts of it will be available online.
Although not directly related to the OpenSceneGraph, once can learn about scene graph technology from such sources as the Open Inventor Mentor, and Performer Programming Guides. The latter is the closer in design to the OpenSceneGraph, although the Performer manuals are in C, alas. Also of use as a background to some of the techniques used is a SIGGRAPH Vis-Sim course.
The OpenSceneGraph uses OpenGL and does so with a deliberately thin layer,
making it easy to control the underlying OpenGL and to extend it with OpenGL
extensions. The close tie with OpenGL is also reflected in the naming of
many of the OpenGL state related classes, and the parameters that they
encapsulate, which means that knowledge of OpenGL itself will go a long way
to understanding how to get the best out of the OpenSceneGraph. To this
end it is worth obtaining a copy of the OpenGL programming guide - `Red
Book` and OpenGL reference guide 'Blue Book'. The main OpenGL
website is also a good source of links and further information.
Professional support is also available in the form of confidential online, phone and onsite support and consultancy, for details contact Robert Osfield at firstname.lastname@example.org.