Open Inventor 8.1 Release Notes


Packaging changes

Starting with this version of Open Inventor, the complete toolkit is provided with three different installers:

  • One Platform-dependent installer which provides the complete Open Inventor SDK including all binaries, include files and data needed to develop an Open Inventor based application for a specific platform and compiler.
  • One Platform-independent installer which provides the complete Open Inventor SDK Documentation including html, MS-help1, and MS-help2 help files.
  • One Platform-independent installer which provides all the demos and examples using CMAKE to create vcproj (Visual Studio) files or Makefiles for a specific platform and compiler.
    Complete documentation on how to use CMAKE with Open Inventor can be found in the : Demos Package Documentation.

A complete Open Inventor installation, equivalent to previous versions, requires downloading and running all three installers. However developers who don't need, for example, another copy of the documentation or examples can save time and disk space by only installing the SDK.

Visual Studio Integrated help support

The Open Inventor reference manual is now provided in the Microsoft Help2 format, allowing Visual Studio developers to access information about Open Inventor classes using the F1 key.

OpenGL extension API access

Starting with this version, Open Inventor provides complete OpenGL extension API wrapping using the OpenGL Extension Wrangler Library (GLEW).

GLEW is a cross-platform open-source C/C++ extension loading library which provides efficient run-time mechanisms for determining which OpenGL extensions are supported on the target platform (see website http://glew.sourceforge.net).

The GLEW API itself is not exposed to Open Inventor developers and no application changes are required.
But note that extension and API dynamic function resolution is now done on a per context basis (GLEW multi-thread mode), so the application must check extension availability or use the OpenGL extension API only when an OpenGL context is currently bound and for each different context used.

This is particularly important when using multiple GPUs with different levels of OpenGL support (in multi-Pipe or Remote mode for example).

OpenGL extensions are now checked for the current context using the new SoGLExtension class.
This class also provides a convenient way to disable Open Inventor usage of some OpenGL extensions by using the OIV_DISABLED_GL_EXTENSION_LIST environment variables or the SoGLExtention::disableExtension() API.

This can be helpful when a GPU driver version has a buggy implementation of an extension and you want to avoid using it or in the rare case that OIV is buggy when using some extension...

New OpenGL context and cache management

OpenGL Context management has been greatly enhanced to better support multi-viewer applications, context sharing (to increase reuse of caches across contexts), remote rendering and multi-thread/multi-pipe rendering.

Most important changes are internal, but some methods are now deprecated, and (by default) contexts are bound only when needed by viewers.

In particular, it means that outside the viewer redraw (render traversal) no OpenGL context is bound.

See Compatibility notes for details.

X3D GeoSpatial / GeoVRML support

X3D GeoSpatial, formerly GeoVRML, is an effort to provide support for representing and visualizing geographic data using the ISO standard X3D / VRML97 (Virtual Reality Modeling Language).
See the X3D GeoSpatial and GeoVRML websites for more information.

Open Inventor implements the following GeoVRML 1.1 standard nodes and their non VRML dependent Open Inventor counterparts:

GeoVRML node

OIV nodes

Description

SoVRMLGeoCoordinate

SoGeoCoordinate

Geographic coordinates node

SoVRMLGeoElevationGrid

SoGeoElevationGrid

Specifies a uniform grid of elevation values within some spatial reference frame

SoVRMLGeoLocation

SoGeoLocation

Used to georeference models

SoVRMLGeoLOD

SoGeoLOD

Level-of-detail management for multi-resolution terrains

SoVRMLGeoOrigin

SoGeoOrigin

Specifies a local geo referenced coordinate system.

SoVRMLGeoTouchSensor

 

Detects when the user has pointed at a specific piece of geo referenced geometry

SoVRMLGeoViewPoint

 

Specifies position from which the user might view the scene.

 

SoGeoRender

Defines render projection

See some example models in the directory $OIVHOME/src/Inventor/examples/data/Models/GeoVRML/

Dynamic parameter refinement

The new SoInteractiveComplexity node allows the application to define different quality parameter values depending on whether a user interaction, for example moving the camera, is occuring.

This means that while the camera is moving some nodes will use a specified parameter value, but when interactive manipulation is stopped these parameters will automatically increase from a min value to max value with a given increment. The values specified in the SoInteractiveComplexity node override the value in the node's fields.

This is a really smart techniques for GPU intensive datasets or rendering effects, in order to maintain an interactive frame rate during manipulation but still get a final image with very high quality.

This mechanism is implemented for a fixed number of existing parameter fields:

  • SoComplexity::value
  • SoComplexity::textureQuality
  • SoShadowGroup::isActive
  • SoShadowGroup::quality

See also VolumeViz Dynamic Parameters.

Object Aligned Bounding Box

Open Inventor is now able to compute and manage Object Oriented Bounding Boxes (OOBB) as well as the traditional Axis Aligned Bounding Boxes (AABB).

Using OOBB can provide better performance for culling, picking and collision detection for shapes that are not generally cubic or axis aligned, however at the cost of higher CPU usage when computing the box.

A common example is the bounding box of a line from point (0,0,0) to (1,1,1). In AABB mode its bounding box is a cube of dimension [1,1,1] where in OOBB its dimension will be close to [0,0,1].

This feature can be globally enabled using the OIV_USE_OOB environment variable, or can be set inside some part of a scene graph through the new SoComplexity::bboxType field.

Warning: The viewAll and adjustClippingPlane methods of all Open Inventor viewers may provide different visual results, while still being correct, because they rely on the computed bounding box of the scene graph returned by the SoGetBoundingBoxAction.

Device Properties API

The API for SoDevice inherited classes has been extended to support querying useful information.
The following new queries are available for all device types (CPU/CUDA/OpenCL/OpenGL):

SoDevice::getTotalMemory()

Returns the total memory in bytes of this device.

SoDevice::getAvailableMemory()

Returns the currently available free memory in bytes of this device.

SoDevice::getLogicalUnits()

Returns the number of logical units of this device.

SoDevice::getDriverVersion()

Returns the driver version of this device.

SoDevice::getDeviceName()

Returns the name of this device.

SoDevice::getDevicesCount()

Returns the number of registered devices.

LIMITATIONS: On some devices the getAvailableMemory() method is not available because of driver limitations and will return the getTotalMemory() results (SoGLDevices for example).

See examples in $OIVHOME/Inventor/examples/Features/DeviceProperties

OpenCL computing framework support

Open Inventor 8.0 introduced a new Computing Framework API supporting CUDA, GL and CPU devices. This version provides a new implementation of the framework for OpenCL, a vendor independent framework for multi-core computing on hetergeneous platforms. The new implementation provides the same level of functionality as our CUDA implementation, based on the following new classes.

Abstract base classes

OpenCL

SoDevice

SoOpenCLDevice

SoDeviceContext

SoOpenCLContext

SoBufferObject

SoOpenCLBufferObject

Because of the common framework basis, the examples already provided for CUDA in 8.0 were easily modified to use OpenCL and the following section provides examples of this usage:

  • Texture Data computing
    Getting/setting SoTexture2/SoTexture3 as an SoBufferObject allows you to apply direct filtering.

    See $OIVHOME/src/Inventor/examples/Features/Compute
    This demo shows computation on the CPU or the GPU using the CUDA or OpenCL algorithms module loaded on demand when the application switches to CUDA or OpenCL.

  • Geometry computing
    The new (in Open Inventor 8.0) node SoBufferedShape gets all its geometry properties from SoBufferObject objects instead of an SoVertexProperty node.

    See $OIVHOME/src/Inventor/examples/Features/BufferObjects/AnimatedShape
    showing dynamic buffered shapes animation.

    See $OIVHOME/src/Inventor/examples/Features/BufferObjects/SoBufferedShape
    A large shape is loaded in multiple SoGLBufferObject nodes; these buffers are used in a SoBufferedShape for rendering.

LIMITATIONS: Only the NVIDIA OpenCL driver implementation has been validated for this version.

Compressed file support

Open Inventor based applications can now directly read and write Zlib compressed Open Inventor (.iv) files.
This feature not only reduces disk space but also significantly reduces loading time for large models in the Open Inventor format.

Reading Zlib compressed files is done transparently within the SoInput class.

To compress an existing .iv file you can use third party tools like gzip or 7-Zip (select GZip format).
To directly write compressed file from your application use the following new method:

SoOutput::setFileProperty(FileProperty::CompressedZlib)

ASCII format .iv files can be compressed 10X in many cases.

MPEG recording/playing enhancements

The SoMPEGRenderer class now records and encodes in a separate thread to avoid any performance impact on user interactivity.

The application can attach an SoMPEGRenderer object to existing So[Qt/Win/Xt/Wx]RenderArea (and derived viewer) classes, then start, stop and pause video recording directly on the viewer class.

Controlling the video recording can be done in two ways:

1) Using a new Open Inventor viewer integrated dialog box:

  • Right-Click in the viewer window to get the viewer popup menu.
  • Select the "Record" option.
  • Then use the dialog box options

2) Using new methods:

  • So[XXX]RenderArea::setMPEGRecorder()
  • So[XXX]RenderArea::getMPEGRecorder()
  • SoMPEGRecorder::record()
  • SoMPEGRecorder::pause()
  • SoMPEGRecorder::stop()

Text rendering enhancements

Text rendering has been significantly enhanced ( SoText2D and SoText3D ).
It is now possible to define different text rendering styles and their associated colors through the new SoTextProperty::style and SoTextProperty::styleColors fields.
Notes that all styles can be combined together.

NONE

http://www.vsg3d.com/support/oiv_doc/common/Text-None.png

UNDERLINE

http://www.vsg3d.com/support/oiv_doc/common/Text-Underline.png

STRIKETHROUGH

http://www.vsg3d.com/support/oiv_doc/common/Text-StrikeThrough.png

DOUBLE_STRIKETHROUGH

http://www.vsg3d.com/support/oiv_doc/common/Text-DoubleStrikeThrough.png

BACK_FRAME

http://www.vsg3d.com/support/oiv_doc/common/Text-BackFrame.png

BACK_FRAME_LINE

http://www.vsg3d.com/support/oiv_doc/common/Text-BackFrameLine.png

The quality of text rendered using textures (see SoFont::renderStyle) can be better controlled using the new SoTextProperty::aliasingFactor and SoTextProperty::textureQualityRange fields and the existing SoComplexity::textureQuality field.

By reducing textureQualityRange (reduces the size of the texture used) and increasing aliasingFactor it is possible to get better rendering quality at higher frame rate and with less GPU resource usage.

Note that the default textureQualityRange can also be specified using the OIV_MIN_TEXTURED_FONT_RES and OIV_MAX_TEXTURED_FONT_RES environment variables.

See examples in $OIVHOME/Inventor/examples/Features/TextProperties

Performance Enhancements

Many rendering nodes were optimized to provide higher frame rate or decrease memory consumption (or both).

Here is a list of the most important improvements:

  • We now use OpenMP in many cases to parallelize internal algorithms. This can be controlled dynamicaly at runtime using the standard OpenMP environment variables if required. In particular it is posssible to disable OpenMP usage by setting the OMP_NUM_THREADS environment variable to 1 (See OpenMP wikipedia documentationfor details and usefull links).

    Using OpenMP provides a near-linear performance increase with the number of CPU cores available, for the following algorithms:

SoIndexedShape::computeBBox

bounding box computation of all inherited indexed shape class

SoNonIndexedShape::computeBBox

bounding box computation of all inherited non indexed shape class

SoNormalGenerator

default shape normals generation

SoArithmetic

most of its algorithms

SoConversion

most of its algorithms

SoSeismic

most of its algorithms

Arithmetic

most of its algorithms

SoVertexProperty

Packed color conversion

So[GL]LazyElement

Packed color conversion

  • Many more geometry shape nodes now allow automatically using Vertex Arrays (VA) or Vertex Buffer Objects (VB0) for rendering when supported by the graphics card. This provides a higher frame rate and potentially 2X less memory consumption when render caching is disabled.

    SoFaceSet uses VA or VBO, if no bump mapping and no PER_FACE normal or color binding

    SoIndexedQuadMesh, SoIndexedPointSet, SoIndexedLineSet uses VA or VBO, use VBO if material and normal binding is PER_VERTEX_INDEXED

    SoCube uses VA or VBO in all cases.

    When SoShapehints::creaseAngle is greater than 0, then the normal generator will compute the number of "sharp edges" during default normal vector computation. SoIndexedTriangleStripSet and SoIndexedFaceSet will use this information to use indexed normals if no sharp edges are present (meaning normals are interpolated across edges), allowing VA or VBO usage for rendering.

    IMPORTANT NOTES: Three new environment variables control different rendering behaviors (See SoPreferences class doc for details)

    • OIV_MIN_VERTEX_VA: Shapes use VA if they contain at least OIV_MIN_VERTEX_VA vertices (default is 0)
    • OIV_MIN_VERTEX_VBO: Shape use VBO if they contain at least OIV_MIN_VERTEX_VBO vertices (default is 0)
    • OIV_MIN_VERTEX_VAVBO_NOCACHEShapes using VBO or VA will deactivate caching if they contain at least OIV_MIN_VERTEX_VAVBO_NOCACHE vertices (default is 10000)

 

  • The Following shapes now support multi texturing, 3D Texture and vertex attributes: SoIndexedPoinSet, SoPointSet, SoIndexedLineSet and SoLineSet.
  • SoExtSelection: from 8X to 200X speedup factor depending on the number of selected nodes and scene graph size.
  • SoBoundingBoxHighLightAction: 6X faster to build the highlighted scene graph and from 2X to 100X better frame rate.
  • Computation of NURBS surface requires less memory. The resulting NURBS can be displayed using VBO for faster rendering. Indexed NURBS curves and surfaces have also been enhanced.
  • SoVRMLBillboardnode performance has been improved by avoiding many bounding box cache breaks.

    The new SoVRMLBillboard::useSphereBBox field has been added to extend the bounding box returned by SoVRMLBillBoard::getBoundingBox() method to the bounding box of the sphere that contains the child bounding box.

    Doing this means that the bounding box is no longer optimal, but more importantly it no longer depends on the rotation of the view requested by SoVRMLBillBoard node. This avoids cache breaks and bounding box recomputation at each traversal.

Miscellaneous Open Inventor Enhancements

  • Error handling classes:
    • SoMemoryErrorclass now allows better memory error management.
      Applications can now setup an SoMemoryCleanupCB callback in the SoMemoryError class that will be triggered if Open Inventor is unable to allocate memory. This callback allows the application to release some unneeded memory or non-vital cache memory and let Open Inventor re-try its allocation request.
    • NEW SoErrorStack class allows access to the program call stack.
  • Subviews
    PoView and PoSceneView are now available in the Open Inventor core library instead of the MeshViz module extension. These classes are very useful for creating rendering "sub-windows", each with their own camera, within the viewer window.  See Compatibility notes for details.
  • Shadows
    Open Inventor rendering nodes support a new VARIANCE_SHADOW_MAP mode that allows soft shadows.   See SoShadowGroup for more information.
    Also see example $OIVHOME/src/Inventor/examples/Features/Shaders/shadowShader
  • IGES and STEP import
    Now preserves the input measuring units through SoInfo nodes in the resulting scene graph.
  • A new library named InventorImage is now in charge of all Image and video manipulations. This library is used internally by Inventor and does not expose and new API or require any change to applications.
  • The FreeType third party software library used to load fonts for text rendering has been updated to version 2.3.9.
  • Viewers:
    • The default viewer size was changed to larger values (800x600 by default) that are more appropriate for today's larger screens. It is now possible to specify the default size using the OIV_VIEWER_SIZE environment variable.
    • FullScene anti-aliasing can now be activated directly from the viewer context preferences popup menu.
    • MPEG video recording can now be activated directly from the viewer context preferences popup menu.
    • Camera rotation in the Examiner viewer can now be constrained to one or more axes, using the new constrainCameraRotation() method.
  • IvTune
    Now allows saving a sub-scenegraph from the treeview and also setting/changing node names.
  • Licensing :License files and license administration program are now installed in <OIV_INSTALL_DIR>/<ARCHITECTURE>/License.
  • Better Catia reader support through the ACIS library (updated to R20-SP2).

    Note: We now support Microsoft VC8 AND VC9 for 32 and 64 bits platforms.

  • Open Inventor based application rendering across a Microsoft Windows Remote Desktop Protocol (RDP) connection is now supported.
    But note that using RDP implies that rendering will switch to the Microsoft generic software driver. Using this driver, 3D hardware acceleration is disabled and only OpenGL 1.1 features are supported! Some Open Inventor features normally supported on modern graphics boards will not function correctly or will be very slow (VolumeViz for example).
  • Documentation
    The Open Inventor SDK now includes PDF versions of the classic Open Inventor books:
    • The Inventor Mentor: Programming Object-Oriented 3D Graphics with Open Inventor, and
    • The Inventor Toolmaker: Extending Open Inventor