Open Inventor Release Notes

Open Inventor 7.1 (April 2008)

Welcome to the final release of Open Inventor 7.1 and its extensions:
DirectViz 7.1  
FXViz 7.1  
HardCopy 7.1  
Open Inventor 7.1  
MeshViz 7.1  
ReservoirViz 7.1  
ScaleViz 7.1
SolidViz 7.1  
TerrainViz 7.1  
VolumeViz 7.1  

Be sure to read the Compatibility notes as well. They contain news about important changes in this release.

Finally, check the "Platform Support" topic below for important news about Open Inventor platform support changes in this release.

Features and Improvements Overview

Highlights of Open Inventor 7.1 include:

Please read this entire section for new features and improvements that may benefit your applications. For this release, most of the significant enhancements were made to Open Inventor, VolumeViz and HardCopy.

Open Inventor Enhancements

Platform Support

There have been important changes in the platform support between Open Inventor 6.1 and 7.0. Here are key points to be aware of:

For additional platform support details, see the System Requirements topic.

Open Inventor 7.0.1 (February 2008)

No new feature was added. See the fixed bugs section.

Open Inventor 7.0 (December 2007)

Welcome to the final release of Open Inventor 7.0 and its extensions:
DirectViz 7.0  
FXViz 7.0  
HardCopy 7.0  
Open Inventor 7.0  
MeshViz 7.0  
ReservoirViz 7.0 (New!)
ScaleViz 7.0
SolidViz 7.0  
TerrainViz 7.0  
VolumeViz 7.0  

You may recognize some of the new features described below that were "previewed" in patch releases of Open Inventor 6.0. It would still be a good idea to read about them in case there have been changes since their initial implementation.

Be sure to read the Compatibility notes as well. They contain news about important changes in this release.

Finally, check the "Platform Support" topic below for important news about Open Inventor platform support changes in this release.

Features and Improvements Overview

Highlights of Open Inventor 7.0 include:

Please read this entire section for new features and improvements that may benefit your applications. For this release, most of the significant enhancements were made to ScaleViz and VolumeViz. ReservoirViz, an extension for displaying very large structured 3D meshes was added. See their release notes for details.

Open Inventor Enhancements

Platform Support

There have been important changes in the platform support between Open Inventor 6.1 and 7.0. Here are key points to be aware of:

For additional platform support details, see the System Requirements topic.

Open Inventor 6.1 (March 2007)

Welcome to the final release of Open Inventor 6.1 and its extensions:
DirectViz 6.1 (New!)
FXViz 6.1  
HardCopy 6.1  
Open Inventor 6.1  
MeshViz 6.1  
ScaleViz 6.1
SolidViz 6.1  
TerrainViz 6.1  
VolumeViz 6.1  

You may recognize some of the new features described below that were "previewed" in patch releases of Open Inventor 6.0. It would still be a good idea to read about them in case there have been changes since their initial implementation.

Be sure to read the Compatibility notes as well. They contain news about important changes in this release.

Finally, check the "Platform Support" topic below for important news about Open Inventor platform support changes in this release.

Features and Improvements Overview

Please read this entire section for new features and improvements that may benefit your applications. Below is a partial list that highlights the more significant improvements in this release. Note that for this release, most of the enhancements were made to ScaleViz and VolumeViz. DirectViz, an extension for doing photorealistic ray-traced rendered, was added. Highlights of Open Inventor 6.1 include:

Please read this entire section for new features and improvements that may benefit your applications. For this release, most of the significant enhancements were made to ScaleViz and VolumeViz. DirectViz, an extension for doing photorealistic ray-traced rendered, was added. See their release notes for details.

Open Inventor Enhancements

Platform Support

There have been important changes in the platform support between Open Inventor 6.0 and 6.1. Here are key points to be aware of:

For additional platform support details, see the System Requirements topic.

Open Inventor 6.0 (March 2006)

Welcome to the final release of Open Inventor 6.0 and its extensions:
FXViz 6.0  
HardCopy 6.0  
Open Inventor 6.0  
MeshViz 6.0  
ScaleViz 6.0 (New!)
SolidViz 6.0  
TerrainViz 6.0  
VolumeViz 6.0  

You may recognize some of the new features described below that were "previewed" in patch releases of Open Inventor 5.0. It would still be a good idea to read about them in case there have been changes since their initial implementation.

Be sure to read the Compatibility notes as well. They contain news about important changes in this release.

Finally, check the "Platform Support" topic below for important news about Open Inventor platform support changes in this release.

Features and Improvements Overview

Please read this entire section for new features and improvements that may benefit your applications. Here is a partial list that highlights the more significant improvements in this release:

Open Inventor
MeshViz
See the MeshViz release notes for details.

ScaleViz (new!)
See the ScaleViz release notes for details.

VolumeViz (and VolumeVizLDM)

See the VolumeViz release notes for details.

Platform Support

There have been important changes in the platform support between Open Inventor 5.0 and 6.0. Here are key points to be aware of:

For additional platform support details, see the System Requirements topic.

Texture-Related Enhancements

There are a large number of texture-related enhancements in this release, as we continue our efforts to give Open Inventor applications convenient access to the latest, most powerful features of OpenGL.

2D Indexed Texture Support Added

2D indexed textures are 2D image textures where each component of the image is a color index value instead of actual color value as with RGBA textures. The color index value is used to select an RGBA color in a color map. Three new classes were added to Open Inventor to support this new feature:

When fragment shaders are available they are used for rendering. Otherwise the GL_EXT_paletted_texture extension is used.

Render-to-Texture Support

Rendering to a texture is a very powerful new feature. You can now pass a scene graph to a texture node and the scene graph is rendered directly into the texture.

The scene graph can even be dynamic. Changes to the referenced scene graph will automatically be reflected in the texture. Furthermore, any scene graphs that contain the texture will be updated as well.

The classes involved in support for this new feature are SoRenderToTextureProperty (new), SoTexture2 and SoTextureCubeMap for onscreen rendering, and SoPBuffer for offscreen rendering.

More Internal Formats Supported

A new field of SoTexture, internalFormat, allows you to specify the internal format of the texture. It gives you great flexibility in controlling how textures are stored on the graphics card.

You specify the desired format using one of the new InternalFormat enum values. Can be AUTO_INTERNAL_FORMAT (default), ALPHA_FORMAT, ALPHA4, ALPHA8, ALPHA12, ALPHA16, etc.

Support for Non-Power-Of-Two Textures

For compatibility with OpenGL, if a texture image's width or height is not a power of 2, Open Inventor will automatically scale the image up or down to the next power of 2. This is convenient for the programmer, but can be time consuming. Now, if the Non-Power-Of-Two (NPOT) extension is available on your graphics board, this extension is used instead of scaling the image.

If you need to disable use of the NPOT extension by Open Inventor, use configuration parameter OIV_USE_NPOT set to 0.

This enhancement affects SoExtTexture2, SoTexture2, SoTextureCubeMap, as well as SoVRMLTexture (and its derived classes).

NOTE: The NPOT extension is only available on relatively new graphics cards.

Automatic Mipmap Generation

A new field of SoTexture, useAutoMipmap, requests OpenGL auto-mipmap generation (if supported). FALSE by default.

DDS Image Support Added

Open Inventor supports reading of the DDS (DirectDraw Surface) file format. DDS textures load faster and use less memory because they are precompressed.

This enhancement affects SoTexture2, SoTextureCubeMap, and SoExtTexture2.

SoDDSImageRW is a new image reading class for DDS import, derived from SoRasterImageRW. This file format is supported by some graphics drivers and loads faster because the compressed data is directly sent to the driver without uncompression.

HDRI Image Support Added

SoTextureCubeMap has a new field, HDRIExposure, that specifies an exposure factor when using an HDRI (high dynamic range image) file. 1.0 is the default.

Manual/Automatic Texture Loading

You can now control whether texture loading is automatic or manual. This is useful to avoid loading textures that are not immediately needed for rendering, for example, if there are many levels of detail in your scene graph.

To support this new feature, there is a new enum Loading, with possible values AUTO (default) or MANUAL. A new field, loadingMode, allows you to specify the loading mode. If MANUAL is set, you can use the following new method to load the texture: 

    void loadTexture();

The following two callbacks can be used to help with the process: 

    void setStartLoadingCallback(SoTexture2CB* cb, void* userData);
    void setFinishLoadingCallback(SoTexture2CB* cb, void* userData);
SoSFImage Supports New Data Types

SoSFImage previously only supported unsigned byte per component. In order to support different texture formats, particularly floating point format, it has been extended to support different data types per component.

A new enum (DataType) is available now to specify the data type. The possible values are: UNSIGNED_BYTE (default), UNSIGNED_SHORT, UNSIGNED_INT32, SIGNED_BYTE, SIGNED_SHORT, SIGNED_INT32, FLOAT.

The following new methods are more generic redefinitions of older methods. The dataType argument allows them to work with any data type. 

    const void* getValue(SbVec2s &size, int &nc, DataType &dataType) 
        const
    const unsigned char *getValue(SbVec2s &size, int &nc) const
    void setValue(const SbVec2s &size, int nc, DataType dataType, 
        const void* data, CopyPolicy copy=COPY)
    void setSubValue(const SbVec2s &subSize, const SbVec2s &offset, 
        void *data)
    void* startEditing(SbVec2s &size, int &nc, DataType &dataType)
    void* getSubTexture(int index, SbVec2s &size, SbVec2s &offset, 
        DataType &dataType)
    void setSubValues(const SbVec2s *subSizes, const SbVec2s *offsets,
        int num, void **data);
Force Sending of Texture Coordinates to OpenGL

This new feature allows you to force the sending of texture coordinates to the OpenGL pipeline without having a texture bound to the corresponding texture unit. This is useful when working with programmable shaders.

There are two ways to activate this new behavior:

  1. Set to TRUE the new field forceSending which was added to the following classes:
    • SoTextureCoordinate2
    • SoTextureCoordinate3

  2. Set environment variable OIV_FORCE_TEX_COORD_SENDING to 1. The default is FALSE.

Only shapes derived from SoVertexShape are affected as SoTextureCoordinate2 and SoTextureCoordinate3 only apply to these nodes.

Only user-specified texture coordinates are affected. Texture coordinates that are automatically computed by Open Inventor are NOT affected.

This was enhancement request 1038.

New Query for Texture Features Support

A new static method, isSupported(), was added to SoTexture to return information about hardware support on your system for various texture features, such as non-power-of-2 textures, floating point texture format, etc.

Text Enhancements

Unicode Support

Unicode is an industry standard for encoding text of all forms and languages for use by computers. Open Inventor now supports Unicode encoding, which allows internationalization of text in a standard cross-platform fashion.

SbString and associated classes like SoSFString have been extended to support the wchar_t type which is used for holding Unicode strings, and all of the text nodes are now able to render Unicode strings.

SbString includes new methods for construction of Unicode strings, new string operators (=, += ,== ,!=, <, >, <=, >=), as well as a new query method (isUnicode()).

To be able to display a particular Unicode character, the selected font must have a character for that Unicode value. Many fonts do not contain a complete set of Unicode characters. However, the shareware Unicode font file "Code2000" seems to work well.

Note that Unicode characters are not directly supported in Open Inventor files. Unicode strings are written as if the bytes in the string were a string of 8-bit characters. The string will be prefixed by "MCS_U_".

New Property node: SoTextProperty

The SoTextProperty node allows you to specify additional text rendering properties, allowing you greater control over the appearance of your text output.

The new fields are:

This node will not affect text nodes unless you set their justification field to the new enum value INHERITED.

New Justification Enum Type INHERITED

In addition to the older justification enum values (LEFT, RIGHT, CENTER), there is now the new value INHERITED.

This change affects SoText3, SoText2, SoAsciiText, and SoAnnoText3. If you set the justification field value to INHERITED, the text alignment will be overridden by the current SoTextProperty.

New Internal Font Computation Engine

In Open Inventor 6.0, text computation is done using the FreeType 2 library (www.freetype.org). FreeType is a customizable and portable software font engine that is capable of producing high-quality output. FreeType allows support of more font formats than in previous Open Inventor versions: TrueType, Type 1, CID-keyed Type 1, CFF, SFNT-based bitmap, X11 PCF (including gz compressed fonts), Windows FNT, BDF, PFR, dfont, etc.

Improved Rendering Quality for 2D Text

Previously, SoFont::renderStyle = TEXTURE could be used to draw high quality antialiased text strings using SoText3. This capability has been extended to apply to SoText2 as well.

New SoFont Methods
New Environment Variables for Text Computation
OIV_FONT_PATH
Specifies a list of paths where font files can be found.

OIV_MIN_TEXTURED_FONT_RES
Specifies the minimum resolution for textured text computation.

OIV_MAX_TEXTURED_FONT_RES
Specifies the maximum resolution for textured text computation.

OIV_MAX_FONT_CACHES
Specifies the maximum number of caches to use during text computation.
New SbString Class Operators

The SbString class now includes the following string comparison operators: <, >, <=, and >=. For example, the "<" operator returns TRUE if the second argument would sort alphabetically after the first argument.

New Example Programs

There are new example programs to illustrate the new text features:

$OIVHOME/OIV\src\Inventor\examples\Features\TextExtensions\DirectUnicode
$OIVHOME/OIV\src\Inventor\examples\Features\TextExtensions\TextProperties

Programmable Shader Enhancements

Vertex Shader Parameter Support

Previous versions had some limitations in specifying parameters for shaders. For example, vertex shader parameters were not supported. These limitations have been removed.

The following classes were added for this support:

Uniform Shader Parameters in the State

Uniform shader parameter nodes can now be included directly in the scene graph. Previously, they could only be attached to the SoFragmentShader and SoVertexShader nodes.

NURBS Enhancements

"Crack-Free" Tessellation

In Open Inventor 6.0, you can now join multiple NURBS surfaces without cracks between them. To support crack-free tessellation, two nodes were added:

as well as a new field:

The new SoNurbsGroup grouping node defines a set of surface patches (NURBS surfaces). NURBS surfaces that are part of the same SoNurbsGroup and which need to be joined must have profiles (SoNurbsProfile) that share the same boundary (SoNurbsBoundary).

The SoNurbsBoundary node is used in the boundary field of SoNurbsProfile. Surfaces which have profiles with the same boundary (i.e., the same SoNurbsBoundary node) will be joined along these profiles.

The directory $OIVHOME/data/models/NurbsCrackFree contains models showing examples of NURBS crack-free tessellation. For each model there is:

Adaptive Tessellation

With adaptive tessellation, more triangles are generated depending on the curvature of the surface. This allows higher quality rendering while still maintaining good performance. This feature is implemented in the SoNurbsProperty node.

Improved Handling of Textured NURBS

The original NURBS tessellation provided by SGI in Open Inventor 2.1 was previously replaced by Mercury except for the case of textured NURBS. Now, even for textured NURBS, the new algorithm is used. This new algorithm resolves a number of longstanding issues.

IvTune Enhancements

Other Enhancements

Support of Floating Point RGBA Buffers

Open Inventor now allows you to request and render into a floating point RGBA buffer. This is useful because this kind of buffer allows for higher precision color.

The classes involved in support for this new feature are:

See details below.

SoPBuffer Enhancements

SoPBuffer was extended to support the Open Inventor graphic configuration mechanism, fast render-to-texture capabilities, and miscellaneous other utilities, as follows:

SoOffscreenRenderer Enhanced
New Collision Detection Class: SoDualSceneCollider

The new class 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.

NOTE: This new class should be used in place of SoCollisionManager. However, for compatibility, SoCollisionManager is still available for use.

Examples: $OIVHOME/src/Inventor/examples/Features/Collision/SceneCollider

SoInput Enhancement -- More File Readers

The following file formats can now be read:

An additional license string is required to unlock each of these file readers. License strings for these readers must be purchased. Please contact your Mercury sales manager for details.

See also "Direct Import of DXF Files" later in this file for a more detailed description of DXF import.

Can Use Mouse Wheel to Zoom/Dolly Camera in Viewers

By default, you can now use the mouse wheel to zoom or dolly the camera when using the Open Inventor viewers (examiner, walk, etc.). The mouse wheel has the same kind of camera movement as the right thumbwheel -- dolly or zoom -- depending on the viewer type and camera type.

Holding down the shift key while rotating the mouse wheel will cause the camera to zoom/dolly twice as fast.

NOTE: This new functionality is not implemented in the SoXt viewer classes, only in SoWin and SoQt. This will be added in a future release.

There are two ways to enable/disable the mouse wheel behavior:

  1. By calling SoXXXViewer::enableMouseWheelDolly(TRUE/FALSE), where XXX is Win or Qt. Default is TRUE.
  2. By setting environment variable OIV_MOUSE_WHEEL_ENABLE to 1 (true) or 0 (false).
NOTE: When rotating the mouse wheel, be careful not to press down too hard. If the mouse button is pressed, you will get the middle mouse behavior: translate up/down/left/right.

This was enhancement request 8.

New Event: SoMouseWheelEvent

There is a new class, SoMouseWheelEvent, which, as you might guess, encapsulates mouse wheel motion events.

The wheel has discrete, evenly spaced notches. When you rotate the wheel, a wheel message is sent as each notch is encountered. Most modern mouse wheels generate an event with a value of 120 per each notch of the wheel. If necessary, you can use environment variable OIV_WHEEL_DELTA to change this value. Pressing the shift key while moving the mouse wheel will generate events of double the wheel delta (i.e., 240 by default).

Included are two new methods: 

    int getDelta() const
    void setDelta(int delta)

These two methods return and set the distance that the mouse wheel has been rotated. A positive value indicates the wheel was rotated forward (away from the user); a negative value indicates the wheel was rotated backwards (toward the user). The values are specified in multiples of the wheel delta.

This was enhancement request 810.

Miscellaneous

New Node: SoIndexedMarkerSet

SoIndexedMarkerSet is a new node, essentially the same as SoMarkerSet, except using indexed coordinates.

New Node: SoIndexedPointSet

SoIndexedPointSet is a new node, essentially the same as SoPointSet, except using indexed coordinates.

Transparency Enhancements
Render Caching Behavior Control

Previously Open Inventor built render caches from the top down, i.e., at the highest possible level in the scene graph first.

Now render caches by default are built from the "bottom up", i.e., leaf nodes ("children") first. This shouldn't affect the visual results, but may improve performance in some cases.

The following methods were added to SoDB: 

    static void prioritizeChildrenCaching(SbBool onOff)
    static inline SbBool isPrioritizedChildrenCaching()

The following new environment variable allows you to enable children first caching: OIV_PRIORITIZE_CHILDREN_CACHING. Default is TRUE.

"Post-Render" Callback Added

Applications can now specify a "post-render" callback. An application can use it to reliably get control immediately before the OpenGL buffer swap. It is not possible to do this (reliably) by adding a node at the end of the scene graph (because of delayed rendering of various kinds, stereo, multi-pass, etc). It is very useful to apply image post-processing operations to the framebuffer. It has no effect on existing programs.

It is part of SoWinRenderArea, SoXtRenderArea, and SoQtRenderArea.

For example, if using SoWinRenderArea, here is the calling sequence and its description (extracted from its header file): 

    void setPostRenderCallback( SoWinRenderAreaRenderCB *fcn, 
                                void *userData = NULL )
Specifies a function to be called after the Open Inventor render traversal and immediately before the OpenGL buffer swap.

Generally the application should not modify Open Inventor state in these callbacks, but they can be useful for special effects using OpenGL calls.

When the callback function is called, Open Inventor has completed normal rendering (including delayed transparent objects, multi-pass, etc.), but no "end of frame" calls (glFlush, glFinish, SwapBuffers...) have been made. The function should return TRUE if "end of frame" handling has been done by the application (Open Inventor will do nothing in this case). If FALSE is returned, Open Inventor will do its normal end of frame calls (normally calling SwapBuffers).

To query the current post-render callback function and data, use 

    SoWinRenderAreaRenderCB *getPostRenderCallback( const void *&userData ) const

NULL is returned if no callback has been specified by the application.

Ability to Synchronize to External Time Value

Sometimes it is desirable for CAVELib applications running in a cluster to use "Cave Time" throughout -- e.g., for all of the time-dependent nodes (e.g., SoVRMLTimeSensor, SoBlinker, etc.) to be using the same clock time as the "realTime" global field.

Previously this was not possible because the time-dependent nodes internally used the getTimeOfDay() method, which returns the system clock time.

To avoid this problem, a new method was added, SoDB::getCurrentTime(). The time-dependent nodes now use this new method internally.

For compatibility with previous versions of Open Inventor, getCurrentTime() behaves the same as getTimeOfDay() by default.

However, if your CaveLib app needs to use Cave Time, set OIV_USE_GLOBALFIELD_TIME to 1, then getCurrentTime() will return the current time based on the global "realTime" field which the CAVELib application can set to Cave Time before each frame.

This was enhancement request 1188.

Annotation Text Maximum Size Limit Increased

A new environment variable has been added to allow you to specify the maximum size of SoAnnoText3 text when RENDER2D_PRINT_RASTER is set: 

    OIV_MAX_ANNO_RENDER2D_SIZE
Previous versions of Open Inventor limited the size to 64 pixels. The default value is now 1000. If you notice a performance issue when rendering and zooming a scene graph containing many SoAnnoText3 nodes, setting this value to a smaller number, such as 64, may improve performance.

This was enhancement request 1137.

Ability to Disable CTRL Key Functionality of Certain Draggers

Per customer request, a new environment variable was added to allow you to disable the CTRL key functionality for the following draggers (and manips):

The environment variable is: 

    OIV_DISABLE_DRAGGER_CTRL_KEY

If set to 1, when the CTRL key is pressed over the dragger, nothing special happens. Otherwise, the CTRL key has its usual behavior, which varies from dragger to dragger.

Like any other environment variable, it can be set directly in the environment or via an Open Inventor configuration file. (See SoPreferences for info on configuration files.)

This was enhancement request 1076.

Bounding Box Can Be Ignored During Traversal

A new field was added to SoNode to indicate whether to ignore the bounding box of this node during bounding box traversal. Default is FALSE. 

    SoSFBool boundingBoxIgnoring;
You can, for example, use this to exclude parts of the scene graph from affecting the viewer's viewAll computation.

Direct Import of DXF Files

DXF is an industry standard real-time 3D scene description format developed and maintained by the Autodesk company.

Mercury Computer Systems has developed a converter to allow direct import of DXF version R14 files into the Open Inventor viewers. (To request support for more recent DXF versions, please contact your sales representative.)

The Mercury DXF converter extracts and converts the DXF data to an equivalent Open Inventor internal data representation, i.e., to an Open Inventor scene graph.

Reading a DXF file into Open Inventor is just like reading in an Open Inventor format file. Open Inventor will open the file and automatically detect that it is an DXF file. Optionally, you can tell Open Inventor explicitly that the file type is DXF: 

    SoInput dxfInput;
    dxfInput.openFile("myDxfFile.dxf");
    dxfInput.setCurFileType(SoInput::DXF);
    SoSeparator *fileContents = SoDB::readAll(&dxfInput);
Ortho/Perspective Camera Toggling: Now Can Preserve Camera Height Angle

Historically, the visual results of toggling back and forth between perspective and orthographic cameras in a viewer have sometimes been surprising. Specifically, the perspective view can become very distorted. This is because when the viewer switches to perspective view, the camera stays in the same position, but the height angle is adjusted so that the size of the geometry appears roughly the same. In order to achieve the same size, the height angle may become very large -- a wide angle lens, in effect -- with the resulting distortion that you see.

This is not an incorrect result -- just one of many possible choices that can be made when switching between camera types.

Since Open Inventor 5.0.2, there is a new method that allows you to request a different behavior when toggling between orthographic and perspective cameras: 

    void setPreserveCameraHeightAngle(SbBool flag)
The corresponding query method is: 
    SbBool isCameraHeightAnglePreserved() const

If TRUE, an SoPerspectiveCamera's heightAngle is preserved if the camera is changed to an SoOrthographicCamera and then toggled back to an SoPerspectiveCamera. This avoids the possibility of increased perspective distortion. For compatibility with existing behavior, the default is FALSE.

These new methods have been added to the following classes:

Orthographic Camera in Viewer: Now Possible to Enable/Disable Seeking

It is now possible to programmatically disable the seek functionality for an orthographic camera (SoOrthographicCamera). Previously, seeking was always enabled.

The following new methods were added: 

    void   enableSeekWithOrtho(SbBool flag)
    SbBool isSeekWithOrthoEnabled() const
If FALSE, the seek functionality is disabled for an SoOrthographicCamera and the seek button is grayed out. For compatibility with existing behavior, the default is TRUE (seeking is enabled).

The new methods were added to the following classes:

Left Mouse Viewing Behavior Control Added to SoQtExaminerViewer

The following new method was added to specify the viewing behavior when the left mouse is pressed:

  void setViewingMode(ViewingMode viewingMode)

New enum ViewingMode: Can be VIEWING_MODE_SPIN, VIEWING_MODE_SPIN_CONSTRAINED, VIEWING_MODE_PAN, VIEWING_MODE_ZOOM.

SoMPEGNavRenderer Enhanced

You can now specify the camera to be used by the MPEG renderer. The following new methods were added to SoMPEGNavRenderer:

     void setCamera(SoCamera* camera);
     SoCamera *getCamera();
SoXtGLGraphicConfig Modified

A new method was added:

     GLXFBConfig* SoXtGLGraphicConfig::getFBConfig()

Returns the fame buffer configuration.

New 4D Vector Classes

The following new 4D vector classes were added:

New 4D Vector Fields

The following new 4D vector fields were added:

Other New Classes
Additions to SbVec3s, SbVec3i32, SbBox3s

The following new constructors and operators were added to make it to convenient to convert from one kind of integer to another.

    SbVec3s (const SbVec3i32 &v) 
    SbVec3s operator = (const SbVec3i32 &v);

    SbVec3i32 (const SbVec3s &v) 
    SbVec3i32 operator = (const SbVec3s &v);

    SbBox3s(const SbBox3i32 &box);
    SbBox3s operator = (const SbBox3i32 &box);
BigImageRender Demo Updated
The BigImageRenderer demo has been updated to use FSAA (full-scene antialiasing).
OGLInfo Updated
The OGLInfo program has been updated to provide information about support on your system for new OpenGL features (non-power-of-2 textures, etc.) that may be used by Open Inventor 6.0.

Open Inventor 5.0 (August 2004)

Welcome to the final release of Open Inventor 5.0 and its extensions:

FXViz 1.2  
HardCopy 5.0  
Open Inventor 5.0  
MeshViz 5.0 (used to be DataViz!)
MultiPipe 3.0  
SolidViz 1.2  
TerrainViz 3.0  
VolumeViz 5.0  

You may recognize some of the new features described below that were "previewed" in patch releases of Open Inventor 4.0. It would still be a good idea to read about them in case there have changes since their initial implementation.

Be sure to read the Compatibility notes as well. They contain news about important changes in this release.

Features and Improvements Overview

Please read this entire section for new features and improvements that may benefit your applications. Here is a partial list that highlights the more significant improvements in this release:

New Platforms
Open Inventor
MeshViz (formerly DataViz)
VolumeViz
HardCopy
MultiPipe

New Platform Support

We are pleased to announce support for Open Inventor on several completely new (for us) platforms, as well as the usual newer versions of compilers and operating systems. Open Inventor is now available for the Apple Macintosh, using the Qt user interface toolkit. With the addition of this support, applications using Open Inventor and Qt should be portable to virtually any desktop system.

Open Inventor is also available for 64-bit PCs using the new AMD64 and EM64T instruction sets (Athlon64, Opteron, Xeon, etc.). These machines are able to still run 32-bit applications at full speed while allowing 64-bit applications to access very large amounts of memory.

Support for Programmable Shaders

Open Inventor 5.0 provides suppport for programmable fragment (pixel) and vertex 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):

Please check the extensions available on your graphics board (for example, using the OGLInfo utility we provide). As a rough guide, ARB_vertex_program is supported on GeForce4 and Radeon 9700 era boards, but ARB_fragment_shader is only supported on GeForceFX and ATI 9800 (or newer) boards.
OpenGL Shader Language (GLSL) is only available on recent boards and generally will require updated drivers.

The following new classes were added for support of programmable fragment and vertex shaders:

The basic approach is to:

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

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

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

On graphics cards that don't support programmable shaders, the shader code will be quietly ignored.

The following examples show a few of the special effects that you can add to your Inventor scenes using programmable shaders:

$OIVHOME/src/Inventor/examples/Features/Shaders/AnimatedFlag
$OIVHOME/src/Inventor/examples/Features/Shaders/PixelLighting
$OIVHOME/src/Inventor/examples/Features/Shaders/ToonShading

Texture Extensions

In Open Inventor 5.0 the texture mapping facilities have been greatly expanded and support features up through OpenGL 1.5.

The following new nodes were added for this support:

SoTextureCombiner is a new texture environment function that provides a wide range of programmable combiner functions using the incoming fragment color, texture source color, texture constant color, and the result of the previous texture environment stage as possible parameters.

SoTextureCoordinateNormalMap generates texture coordinates matching the vertex’s transformed eye-space normal. This can be useful for texture-based diffuse lighting models.

SoTextureCoordinateObject specifies texture coordinates that are a linear combination of the object coordinates of the vertex.

SoTextureCoordinateReflectionMap generates texture coordinates (s,t,r) matching the vertex’s eye-space reflection vector. This can be useful for environment mapping without the singularity inherent in sphere map mapping.

SoTextureCubeMap Cube map textures provide a new texture generation scheme for looking up textures from a set of six two-dimensional images representing the faces of a cube. Cube map textures are often used within shader programs to implement effects such as reflection or refraction.

SoTextureMatrix is similar to SoTextureTransform but allows you to specify an arbitrary matrix. This can be useful for multitexturing.

Multitexturing

There is now full support for multitexturing with the most useful shapes: SoCube, SoSphere, SoCone, SoCylinder, SoFaceSet, SoQuadMesh, SoTriangleStripSet, SoIndexedQuadMesh, SoIndexedTriangleStripSet, SoIndexedFaceSet, and SoIndexedTriangleStripSet. The multiple textures are specified using a new node, SoTextureUnit.

Multitexturing allows more complex shading models than does the application of a single texture per pass.

If the graphics board supports multitexturing, then multiple textures, each defined by a texture unit, can be applied to the same shape. The maximum number of texture units depends on the board and can be queried using getMaxTextureUnit.

Example: $OIVHOME/src/Inventor/examples/Features/MultiTexturing

Other New Texturing Features

Direct Import of OpenFlight Files

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.

Mercury Computer Systems has developed a converter to allow direct import of OpenFlight (15.7) files into the Open Inventor viewers. The Mercury OpenFlight converter extracts and converts the OpenFlight data (binary format files) to equivalent Open Inventor internal data representations (Open Inventor scene graph).

Reading an OpenFlight file into Open Inventor is just like reading in an Open Inventor format file. Open Inventor will open the file and automatically detect 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);

Transparency

Improved Transparency Rendering (By Sorting Triangles)

Four new transparency types were added to SoGLRenderAction:

The SORTED_OBJECT_TRIANGLES_* types sort the triangles on a per-object basis. If you need more accurate transparency and the transparent objects in the scene do not intersect one another, this is the transparency type to select. Performance for this type of transparency is comparable to the other delayed transparency types.

The SORTED_TRIANGLES_* types sort the triangles on a per-scene basis. In the case where the transparent objects intersect one another, this is the transparency type that provides the most accurate results.

Performance for this type of transparency depends on the number of interleaved triangles for the current axis of sorting. The best performance is comparable to other delayed transparency types; under the worst conditions, sorting the triangles can be very time consuming.

The *_ADD types use additive blending. The *_BLEND types use multiplicative alpha blending.

New Node: SoTransparencyType

This new node allows you to control the transparency type (SCREEN_DOOR, DELAYED_BLEND, etc.) on a per-shape basis.

This can be useful if you want to apply one of the more "expensive" transparency types to a specific portion of your scene graph rather than to the entire scene graph.

The existing setTransparencyType methods (So*RenderArea and SoGLRenderAction) set the transparency type that will be used if no SoTransparencyType node is found.

Improved Render Caching

Previously, when using a delayed or sorted transparency type, it was not possible to render cache transparent objects or any separator above them in the scene graph. Open Inventor 5.0 is able to render cache separators above the transparent object in most cases. This avoids a performance penalty for opaque objects in the same part of the scene graph as the transparent objects.

Fast Edit Mode

A new field, fastEditing, has been added to SoSeparator. It allows you to modify the sub-scene graph of the separator without redrawing the entire Inventor scene; only the modified part is redrawn.

If fast editing is enabled, during a normal traversal, the image buffer (OpenGL back buffer) is saved, optionally the depth buffer is saved, and a delayed render is scheduled. During the delayed render, the back buffer is restored, the depth buffer is restored (if it was saved), then the separator's children are rendered.

Use SoGLRenderAction::setFastEditSavePolicy method to specify the kind of fast editing allowed: DISABLE, EACH_FRAME, or WHEN_NEEDED.

This feature is valuable when you need to frequently modify a relatively small sub-graph in a large scene graph that cannot be rendered at interactive rates. For example, moving a 3D cursor through the scene.

Example: $OIVHOME/src/Inventor/examples/Features/FastEditing

More New Nodes

SoExtrusion (Useful for Well Bores)

SoExtrusion is a new node for creating geometric shapes based on a 2D cross section along a 3D spine. It is more versatile than SoVRMLExtrusion node because it supports PER_FACE and PER_VERTEX material properties (colors and transparency) whereas SoVRMLExtrusion shapes can only have a single overall material.

An example program showing the use of SoExtrusion to do a well-bore plot is provided:

$OIVHOME/src/Inventor/examples/Techniques/WellBore

Background Nodes (Gradient and Image)

SoGradientBackground and SoImageBackground are new nodes for applying a background to a scene. When the window is resized, the background is automatically adjusted.

SoGradientBackground generates a vertical gradient using two colors that you specify. The swapColors field allows you to swap the colors easily.

SoImageBackground provides a convenient way of rendering an image in the background of the scene. The texture can be:

Example: $OIVHOME/src/Inventor/examples/Features/BackgroundNode

Qt

[Win32] Inventor Qt Support Repackaged

NOTE: This change primarily concerns users who have Qt installed on their system and who plan to use Qt in their Open Inventor application programs. Mercury will continue to deliver a single prebuilt InvQtxxx.DLL to allow people who don't have any Qt to run (but not build) the pre-built QtLargeModelViewer and IvTune applications.

In the original release of Open Inventor 4.0, it was necessary to supply a different version of InvQtxxx.lib and InvQtxxx.DLL for each supported version of Qt (3.1.2, 3.2,3.3) and each supported version of VC (6.0, 7.0, 7.1). This is because the SoQt DLL supplied by Mercury depends on the specific name of the Qt DLL, and for each release of Qt, the names are different.

Another issue was that the SoQt DLL supplied by Mercury could conflict with the Qt DLL supplied by an evaluation version of Qt.

Now we deliver a tool called InvQtxxxBuilder (where xxx is the current version of Open Inventor) that will build the corresponding InvQtxxx.DLL using the version of Qt identified by the QTDIR environment variable. If you have an evaluation version of Qt, it's no problem. The SoQt DLL will be built with whatever version of Qt you have.

In addition to building the SoQt DLL, the builder also builds a few other DLLs and demo programs that depend on Qt. See below ("What the InvQt builder does") for details.

The InvQt builder is in the top level of your installation directory.

Here's what you will need to do:

What the InvQt builder does:
  1. Builds the Open Inventor Qt DLLs
    The IvQtxxx.DLLs are built with your currently installed version of Qt, then copied into %OIVHOME%\Program.

  2. Builds the Inventor Qt Designer plugin
    The plugin for Qt Designer named SoQtWidgetPlugin.DLL is built with your Qt, then copied into %QTDIR%\plugins\designer.

  3. Builds QtLargeModelViewer.exe
    The QtLargeModelViewer.exe is built with your Qt, then copied into %OIVHOME%\Program.

  4. Builds IvTune.DLL and IvTuneViewer.exe
    IvTune.DLL and IvTuneViewer.exe are built with your Qt, then copied into %OIVHOME%\Program.

You can also, of course, rebuild InvQtxxx.DLL whenever you switch to a newer version of Qt (as long as it is binary compatible with Qt 3.1.1.)

Open Inventor Plugin for Qt Designer

Open Inventor by Mercury now provides a plugin for Qt Designer. This plugin extends the set of available widgets in Qt Designer so that an Open Inventor 3D viewer can easily be integrated into the application's user interface.

On Windows, the plugin DLL is automatically created by the Open Inventor SoQt installer (the tool that builds SoQt after Open Inventor has been installed) and will be placed in the designer plugin directory (for example, C:\Qt\plugins\designer).

On UNIX or Linux, you must build the plugin library yourself, using the supplied makefile. The makefile will copy the library into the designer plugin directory (for example, $(QTDIR)/plugins/designer).

QtLargeModelViewer Demo Program Enhanced

QtLargeModelViewer has been enhanced. The most significant enhancements include:

X3D (Formerly VRML)

The ISO VRML97 standard is being updated and is now known as X3D. X3D includes a significant number of new nodes,new fields, and, in some cases, changed fields. (See the Compatibility notes for details.)

Support for Latest X3D "Classic VRML" File Format

X3D now specifies two file formats. One, "Classic VRML", is the VRML97 syntax, except that the header is slightly different. Open Inventor can read and write this file format.

The other file format is an XML syntax format. Open Inventor does not support this file format directly. However, there are tools available to convert between the two formats, which are semantically equivalent. See www.web3d.org.

Level 4 except ColorRGBA node. This node reads in and writes out but is not functionally implemented.

Updated Fields in Existing X3D/VRML Nodes

In order to bring the existing VRML97 nodes into compliance with the X3D specification, new fields and eventOuts were added to some of the nodes.

See the Compatibility topic Changes to VRML97 Nodes for details.

Support for New Nodes, Including 2D Geometry Nodes

The following new X3D nodes were added:

Classes marked with NA can be read and written, but there is no action implemented for them at this time.

New Event Utility Nodes

Event utility nodes have been added to Open Inventor 5.0. They are implemented as new VRML/X3D nodes since they are defined in the X3D specification. The following new nodes were added for this support:

Event utilities perform three types of functions:

See the Support for X3D section for a more comprehensive discussion of X3D support in Open Inventor.

New 2D Geometry Nodes

New 2D geometry nodes have been added to Open Inventor 5.0. They are implemented as new VRML/X3D nodes since they are defined in the X3D specification. The following new nodes were added for this support:

Sample Open Inventor files using these new geometry nodes are in:

$OIVHOME/data/models/VRML2/2DGeometry

See the Support for X3D section for a more comprehensive discussion of X3D support in Open Inventor.

New 2D Interpolator Nodes

New 2D interpolator nodes have been added to Open Inventor 5.0. They are implemented as new VRML/X3D nodes since they are defined in the X3D specification. The following new nodes were added for this support:

See the Support for X3D section for a more comprehensive discussion of X3D support in Open Inventor.

Stereo Support

Direct support for Sharp's RD3D Autostereo Laptop

Open Inventor 5.0 now has direct support for the Sharp autostereo display (basically vertical interlaced, but with a special adjustment to the image). This works, for example, on the RD3D laptop. The standard Open Inventor stereo dialog (on Windows) has been extended to show a specific choice ("Sharp 3D LCD") for this display.
There is also a new config file keyword to select this kind of stereo: OIV_STEREO_GREENSHIFT.

Stereo Test Pattern Option

If the configuration keyword OIV_STEREO_TESTPATTERN is set, when stereo is enabled, Open Inventor will display a simple test pattern on top of the scene (it's probably best not to have anything else in the scene). It displays a blue rectangle which should be visible only to the left eye and a red rectangle which should be visible only to the right eye. This allows you to confirm the display is actually doing stereo and that the left/right eye images are displayed in the correct order.

SpaceBall/SpaceMouse

SoQtSpaceball Implemented

SoQtSpaceball is now implemented.

SpaceBall/SpaceMouse Supported on More Platforms

In Open Inventor 5.0, a change was made in how Open Inventor supports the SpaceBall/SpaceMouse on UNIX/Linux. (There was no change to its support on indows.)

SpaceBall/SpaceMouse Support Added to QtLargeModelViewer and VolRend

SpaceBall/SpaceMouse support has been added to the QtLargeModelViewer and VolRend (VolumeViz) demos. See the QtLargeModelViewer documentation and the VolRend readme file for details.

Offscreen Rendering

SoOffscreenRenderer Can Render Large Images

SoOffscreenRenderer now automatically manages large image output using tiles. Tiles can be tracked during the process through the new SoOffscreenTileObserver and SoOffscreenTileProperty classes.

In previous releases, the largest image that you could render was limited by the size image that could entirely fit into your system memory. This constraint has been removed for some file formats. As long as an individual tile of the image can fit into system memory, you can render as many tiles as you want, resulting in an overall image size as large as you want. If you are writing the image to disk, of course you will be limited by the amount of free space on your disk. Fortunately, disk space is a relatively plentiful resource nowadays.

SoOffscreenRenderer Can Share OpenGL Contexts

A new method in SoOffscreenRenderer (setShareContext) allows you to share an already existing OpenGL context with the offscreen renderer.

This avoids the necessity to re-generate textures and display lists if they are already available in another OpenGL context (the viewer context, for instance). This can dramatically reduce offscreen rendering time, depending on your scene graph.

A corresponding query method (getShareContext) is also available.

Here's how you might use these new methods to share OpenGL contexts:

SbGLShareContext ctxInfo=pViewer->getShareContext();
pOffscreen->setShareContext(ctxInfo);
Enhanced Example Program

Example: $OIVHOME/src/Inventor/examples/Features/BigImageRender

This example program has been completely rewritten. It now allows you to select the output image size, the output format (including several new formats: Sun Raster, JPEG 2000, PNM, and PGX), and to request output of individual tiles if the output is tiled.

SoBigImageRenderer Now Obsolete

Although you are not required to change existing applications, SoBigImageRenderer should not be used in new development.

Image Files

Support for JPEG 2000 Files (Better Compression)

Open Inventor now supports both reading and writing JPEG 2000 format image files.

From the JPEG website page on JPEG 2000 (http://www.jpeg.org/JPEG2000.html):

"JPEG 2000 is a new image coding system that uses state-of-the-art compression techniques based on wavelet technology."

JPEG 2000 supports both lossy and lossless compression. It provides both better compression and better (restored) image quality than JPEG.

You do not need to do anything special to use this feature. Open Inventor will automatically detect that a file is in JPEG 2000 format and decode it appropriately.

Utility Classes for Reading/Writing Image Files

Several new classes for raster file management have been added:
SbRasterImage, SoBMPImageRW, SoGIFImageRW, SoJP2ImageRW, SoJPEGImageRW, SoPGXImageRW, SoPNGImageRW, SoPNMImageRW, SoPSImageRW, SoRasterImageFile, SoRasterImageIO, SoRasterImageRW, SoRasterReaderSet, SoSGIRGBImageRW, SoSUNImageRW, SoTIFFImageRW.

These classes are used internally by Open Inventor and are provided to our customers as convenient cross-platform utilities should they need to manage raster files. It is not necessary to use these classes in an Open Inventor application.

Licensing

[Win32] Improvements to License Admin program (LAdmin)

Several new features were added to LAdmin to make it more user friendly.

General Licensing Improvements

Miscellaneous

Support for Full-Scene Antialiasing

Full-scene antialiasing is now available. As the older multipass antialiasing can have very poor performance for large scenes, full-scene antialiasing (multi-sample) is recommended when the hardware supports it.

This node has no effect if full-scene antialiasing is not supported in the graphics hardware or has not been enabled. Full-Scene Antialiasing can be enabled by defining a graphic configuration template, by calling the method SoWinGLWidget::setFullSceneAntialiasing() or (on some systems) by the user through the system display properties dialog.

You can then control sub-scene graph antialiasing by inserting the new property node, SoFullSceneAntialiasing. It has a field to allow or disallow use of the feature for certain parts of the geometry (not the same as enabling/disabling the feature!) and another field allowing you to specify what kinds of primitives should be antialiased (lines, points, polygons, text, or all). For certain primitives antialiasing may be undesirable, for example bitmap text (SoText2 etc) may be "blurred" by antialiasing.

The following environment variables allow you to specify the default values for these fields:

OIV_FULL_SCENE_ANTIALIASING <int>

Sets default value of "on" field. That is, _allows/disallows_ use of the feature for subsequent primitives in the scene graph

OIV_FULL_SCENE_ANTIALIASING_FILTER <string>

Sets default value of filter field using string value ALL or any combination of LINES, POINTS, POLYGONS, and TEXT

The following OpenGL extensions are required for its support:

ARB_multisample and ARB_pixel_format.

If your system has the NV_multisample_filter_hint extension, you can specify the antialiasing quality level.

Support for Vertex Buffer Objects (VBOs)

SoShapeHints has a new field (useVBO) that allows you to speed up the rendering of non-cached indexed shapes.

The following OpenGL extension is required for VBO support:

GL_ARB_vertex_buffer_object.

Example: $OIVHOME/src/Inventor/examples/Features/VBO

New Text Rendering Mode (Antialiased 3D Text)

A new field, renderStyle, was added to the SoFont node. It applies to SoText3 (always) and SoAnnoText3 when the SoAnnoText3Property::renderPrintType field has the value RENDER3D_PRINT_VECTOR or RENDER3D_PRINT_RASTER. It does not apply to stroke fonts.

Three render styles are supported:

A new configuration parameter, OIV_FONT_RENDERSTYLE, allows you to set the initial value of the font render style.

[Win32] Improved OGLInfo Program

The OGLInfo program has been enhanced to use DialogViz to present the OpenGL information organized in a tabbed dialog. It includes general info, an alphabetic list of the OpenGL extensions available on your system, the list of available pixel formats, and info about support for various Open Inventor features that require specific OpenGL extensions. (This last item is info that was previously provided by the ivExtInfo program.)

You can use the File menu to save the info to a text file.

[Win32] Open Inventor Class Documentation Accessible from Visual Studio IDE

For an Open Inventor developer it can be extremely convenient to have direct access to the Open Inventor class documentation from within the Visual Studio IDE. For example, to be able to highlight an Open Inventor class or method in your code, and press F1 to bring up the relevant information from the Open Inventor Reference Manual.

There was no change in the support for Visual Studio 6.0. The Reference Manual is (still) a .chm file, in Microsoft HELP format. You can (still) access the class documentation from within the IDE or externally (e.g., by double-clicking on the file in the Windows Explorer).

For Visual Studio .NET/NET 2003, the Reference Manual is now provided in Microsoft HELP 2 format, which allows integrated access from the IDE.

With this format, however, there is not a direct link between the HELP 2 files (.hx* files) and the Windows application to display the document, meaning that you can't just double-click on one of the files in the Windows Explorer to open the Reference Manual.

We supply a shortcut in the Start Menu submenu "Open Inventor 5.0 for .NET [2003]->Documentation->Reference Manual" which runs dexplore and displays the Open Inventor Reference Manual. (Microsoft Document Explorer (dexplore) is automatically installed with the MSDN for Visual Studio .NET/.NET 2003 or Microsoft Visual Studio .NET/.NET 2003 installation.)

NOTE: If you install Open Inventor 5.0 for .NET/.NET 2003 while MSDN for Visual Studio .NET/.NET 2003 or Microsoft Visual Studio .NET/.NET 2003 are not installed, you must register the documentation manually by running

%OIVHOME%\doc\ReferenceManual\MSHelp2RefMan\register.bat.

This script is called automatically by the Open Inventor installer but has no effect if .NET/.NET 2003 are not installed in your computer.

New Methods to Clean Up Open Inventor Allocated Memory

SoDB, SoWin, SoXt, SoQt, SoNodeKit, and SoInteraction now have a finish method that you can call at the end of your application to free (most of) Open Inventor's internal static memory allocations.

If you are using a memory leak detector, calling finish will eliminate a large number of false positives that have historically been an annoyance to programmers trying to track down "real" memory leaks.

Although there is no requirement to call finish, for "cleanliness" we recommend that all applications do call it.

Please note that to write a really "clean" application, you must still free memory that your app has allocated or caused to be allocated. For example, even for a very trivial program, you would need to delete the viewer object and unref the root of the scene graph.

SoSearchStepAction Extends SoSearchAction

SoSearchStepAction is a new action that extends SoSearchAction and allows you to add a callback to filter the paths before they are added to the path list. The callback is called just before the found path is added to the list. The callback can allow or disallow the addition of the path to the list. This class can be of particular use when the found paths are potentially numerous and you want to filter the returned path list to return only some of them.

Third Party Libraries Are Now Dynamically Loaded

Open Inventor now loads external libraries (e.g., libTiff, libJpeg, etc.) dynamically. This has the advantage that the external code is only loaded if you actually need to use it.

For example, the libTiff library would only be loaded if you were trying to read or write a Tiff file using SoTexture2(3), SoOffscreenRenderer, or one of the other classes that reads/writes Tiff files.

No application code changes are required, but the new DLL/lib files must be redistributed with your application.

The external libraries have also been renamed. This allows Open Inventor to load the specific version of the library that it needs, while allowing the application to link with a different version of the library if desired.

Here are the new library names:

Windows
  • IvDLALut(D).dll
  • IvDLOpenAL32(D).dll
  • IvDLFlt(D).DLL
  • IvDLFreeType(D).DLL
  • IvDLJasper(D).dll
  • IvDLJpeg(D).dll
  • IvDLPng(D).dll
  • IvDLTiff(D).dll
  • IvDLZlib(D).dll
Spatial sound management
Spatial sound management
OpenFlight support
FreeType support
JPEG 2000 support (import/export)
JPEG support (import/export)
PNG support (import/export)
TIFF support (import/export)
Compression library
UNIX