1.9. Cross-Platform Extensions

Large Model Visualization (LMV)

Open Inventor supplies a set of classes designed for real-time rendering of very large models. These tools can be divided into several categories:

Geometry simplification

Also known as mesh decimation, this technique allows parts of the geometry (triangles) to be removed from the shape before sending it to the graphics pipeline. The level of decimation (number of resulting triangles) can be controlled by the user.

Automatic level of detail

Open Inventor already includes an LOD node (SoLOD SoLOD SoLOD ). The geometry simplification feature allows Open Inventor to automatically build different levels of decimation as children of LOD nodes.

Level of simplification node

This is a specialized LOD that also stores the decimation percentage for each child, which makes it very useful for maintaining frame rate.

Adaptive viewer

The Open Inventor viewers have been extended to have a target frame rate. The viewer can force LOD and level of simplification nodes to use lower or higher levels of decimation.

Non-hierarchical traversal

The SoRenderList SoRenderList SoRenderList classes allow a linear or spatial organization of objects which may be sorted to optimize traversal. Occlusion culling ( SoOcclusionCulling SoOcclusionCulling SoOcclusionCulling ), octree-based culling ( SoOctreeOrdering SoOctreeOrdering SoOctreeOrdering ), and others can significantly improve your frame rate.

Get primitive count action

This action (SoGetPrimitiveCountAction SoGetPrimitiveCountAction SoGetPrimitiveCountAction ) returns the number of triangles, lines, etc. in a scene graph or a path.

Multithreading

Using multiple threads in an application can increase overall performance by making use of multiple processors, or better use of a single processor. This also enables use of multiple graphics pipes. Now, multiple graphics windows can each have their own rendering thread, multiple threads can simultaneously traverse the same scene graph, and modification and traversal of the scene graph can safely occur in different threads. Open Inventor can also be used in immersive VR applications based on tools like CAVELib™ and Multipipe SDK™.Chapter 24, Multithreading, gives you full details on multithreading.

Immersive Virtual Reality Support

The SoTrackerEvent SoTrackerEvent SoTrackerEvent and SoControllerButtonEvent SoControllerButtonEvent SoControllerButtonEvent classes have been designed to be useful in immersive VR applications that use tracking. For instance, a “wand” device can generate SoTrackerEvents when moving and SoControllerButtonEvents when a button is pressed. All classes that respond to SoMouseButtonEvent SoMouseButtonEvent SoMouseButtonEvent (i.e., SoSelection SoSelection SoSelection , SoExtSelection SoExtSelection SoExtSelection , etc.) also respond to SoControllerButtonEvents. All dragger classes also respond to SoTrackerEvents and SoControllerButtonEvents. So, for example, a wand input device can be used to interact with draggers and manipulators in an immersive environment. Chapter 26, Immersive Virtual Reality discusses these events.

Collision Detection

Open Inventor supports detection of collisions between the viewer (camera) and the scene, collisions between objects in the scene, as well as collsions between two scene graphs, one moving and one static. The following classes have been added to handle these kinds of collisions:

SoCollisionViewer

Prevents the camera from penetrating walls, floors, or other objects, making viewer control much more comfortable and realistic (“solid” camera).

SoIntersectionDetectionAction SoIntersectionDetectionAction SoIntersectionDetectionAction

Analyzes a scene graph (or subgraph) to detect whether shapes are intersecting, and optionally return the intersections to the application.

SoDualSceneCollider SoDualSceneCollider SoDualSceneCollider

Performs very fast collision detection for the specific case of two scene graphs, one static, and one moving. This class has been designed to detect collisions between very large scenes (i.e., containing millions of triangles) while still allowing interactive display of the two scenes. You can retrieve information about colliding triangles, coordinates of common points, and so forth. This is useful, for example, for walk-through of a complex factory environment.

Chapter 23, Collision Detection explains how to use these classes.

Stereo Enhancements

Open Inventor supports high quality stereo projection with different types of stereo modes to render your virtual model with high realism. Software stereo is supported as well as hardware stereo (OpenGL stereo). Furthermore, a new graphical user interface dialog box, accessible from the Stereo menu item of the viewer popup menu, allows the user to interactively select the stereo mode and make adjustments to various stereo parameters.Chapter 19, Stereo Viewing , describes how to use and configure these different stereo types.

VRML 1.0, VRML97, and X3D Support

Open Inventor supports VRML 1.0, VRML 2.0 (VRML97), and X3D nodes. This is an advantage over other graphics toolkits because the VRML nodes are fully integrated, native objects in Open Inventor. This avoids the problem of translating nodes into a different representation and potentially losing information or generating inefficient VRML when writing them back out. Using Open Inventor you have complete, precise control over the nodes and their field values.Chapter 22, VRML97/ X3D Extensions explains the use of VRML 2.0 and X3D nodes.

Shader Support

Open Inventor provides support for programmable vertex, geometry, and fragment (pixel) shaders, allowing you to take advantage of the latest generation of graphics cards to produce more advanced real-time rendering effects.

Programming in the following languages is supported (depending, of course, on support for these shader languages by your graphics card):

  • ARB_ language (ARB_vertex_program or ARB_fragment_program),

  • NVIDIA Cg,

  • OpenGL Shading Language (GLSL)

The following classes provide support for programmable vertex, geometry and fragment shaders:

The basic approach is to:

  1. Write your shader code and load it into a SoVertexShader and/or SoGeometryShader and/or SoFragmentShader node. Use SoShaderParameter to set parameters (float, integer, vector, etc.) as necessary.

  2. Combine your shaders into an SoShaderProgram SoShaderProgram SoShaderProgram . They should be directly referenced by the multiple field SoShaderProgram::shaderObject.

  3. Insert this SoShaderProgram SoShaderProgram SoShaderProgram object in your scene graph above above the shapes in the scene graph that should be affected by it

Chapter 21, Shaders deals with this topic.

Remote Rendering

Remote rendering allows an Open Inventor application to both execute and render on a remote server machine. Only the optimized and compressed rendered images are sent to the local machine. This allows very large data sets to be centralized and handled on a machine with more memory, processors, and graphics hardware.

Chapter 27, Remote Rendering deals with this extension.

Starting with Open Inventor 6.1, it is also possible to do remote rendering on a cluster using ScaleViz. See Chapter 3, ScaleViz.

Action Extensions

In addition to the actions for large model visualization and collision detection, the following new actions are available:

Texture Extensions

Open Inventor has followed the evolution of graphics boards and OpenGL in terms of texturing support. Furthermore, numerous other features have been added to provide more flexibility and improve performance. The following features have been added:

Dynamic Library Management

When creating your application with Open Inventor, you may need to use external dynamic libraries for specific purposes. However, the need for these libraries can depend on the use of the application. In order to save memory and loading time at start-up, you can load these dynamic libraries “on the fly” only when required.

The class SoDynamicLibManager manages the loading and the unloading of a dynamic library (cross-platform). You can query the list of all loaded libraries or whether a specific library is currently loaded. You can also inquire whether a specific library supports a particular function.

This class is used by Open Inventor to load the following libraries: Zlib, libJpeg, libTiff, libPng, libJasper, OpenAL (Windows only), FreeType, OpenFlight, and NVIDIA CG.

The library name given to the load method can include an absolute or relative path. If no path is supplied, the library will be searched for in the following paths:

  • Windows: The application directory, the current directory, the system directory, the Windows directory, %PATH%, and %OIV_LD_LIBRARY_PATH% (single path).

  • Unix: $LD_LIBRARY_PATH, $OIV_LD_LIBRARY_PATH (single path).

  • Mac OS: $DYLD_LIBRARY_PATH, $OIV_LD_LIBRARY_PATH (single path).

OpenFlight Support

OpenFlight is an industry standard real-time 3D scene description format developed and maintained by the MultiGen-Paradigm company. It was originally created in response to a need for database transportability within the visual simulation community.

A converter allows you to import OpenFlight (Version 15.7) files into the Open Inventor viewers. The OpenFlight converter extracts and converts the OpenFlight data (binary format files) to an equivalent Open Inventor scene graph.

Reading an OpenFlight file into Open Inventor is just like reading in any other kind of file. Open Inventor will open the file and automatically detects that it is an OpenFlight file. Optionally, you can tell Open Inventor explicitly that the file type is OpenFlight:

SoInput fltInput;
fltInput.openFile("myOpenFlightFile.flt");
fltInput.setCurFileType(SoInput::OpenFlight);
SoSeparator *fileContents = SoDB::readAll(&fltInput);
  
SoInput fltInput = new SoInput();
fltInput.OpenFile("myOpenFlightFile.flt");
fltInput.SetCurFileType(SoInput.FileTypes.OpenFlight);
SoSeparator fileContents = SoDB.ReadAll(fltInput);
SoInput fltInput = new SoInput();
fltInput.openFile("myOpenFlightFile.flt");
fltInput.setCurFileType(SoInput.FileTypes.OpenFlight);
SoSeparator fileContents = SoDB.readAll(fltInput);

Other Node Extensions

In addition to the extension nodes mentioned previously, the following new nodes have been added by FEI:

Other Extensions