There are two potential changes when working with a GLRender() method:

For additional information, see “How to Convert GLRender() Methods” in “Managing the Material State.”

This section discusses two changes to the readInstance() method: “Additional Argument to readInstance()” and “Implementation of readInstance() for Group Nodes Changed.”

SoInput *in, unsigned short flags

// Reads stuff into instance of SoGroup. Returns FALSE on 
// error. Also deals with field data (if any), so this method 
// should also be useful for most subclasses of SoGroup.
//
// Use: protected
SbBool
SoGroup::readInstance(SoInput *in, unsigned short flags)
{
    SbBool readOK = TRUE;
    // First, turn off notification for this node
    SbBool saveNotify = enableNotify(FALSE);
    // Read field info. We can't just call
    // SoNode::readInstance() to read the fields here
    // because we need to tell the SoFieldData that it's ok 
    // if a name is found that is not a valid field name - 
    // it could be the name of a child node.
    SbBool notBuiltIn; // Not used
    readOK = getFieldData()->read(in, this, FALSE, 
                                  notBuiltIn);
    if (!readOK) return readOK;
    // If binary BUT was written without children (which can 
    // happen if it was read as an unknown node and then 
    // written out in binary), don't try to read children:
    if (!in->isBinary() || (flags & IS_GROUP)) 
        	readOK = readChildren(in);
    
    // Re-enable notification
    enableNotify(saveNotify);
    return readOK;
}

Node copying now works correctly. For example, multiple references to a node (through children, fields, or connections) under the node to be copied are no longer copied individually; multiple instances of a single copy are created instead.

These changes required a change to the extender API. The changes affect you only if you have created a new node class and have implemented a copy() method for it that differs from that of its base class.

In Inventor 2.1, the SoNode::copy() method is no longer virtual. Instead, the copy() method creates an empty node of the correct type and then calls the virtual copyContents() method on it to copy from the existing node. The default implementation of copyContents() for SoNode copies the field values. The implementation for SoGroup copies the children as well. If your node has other (non-field, non-child) information that needs to be copied, redefine copyContents() for it. See “The copyContents() Method” for more information.

The SoShapeHintsElement methods setFilled(), setClipped(), isFilled(), isClipped(), getDefaultIsFilled(), and getDefaultIsClipped() are no longer supported.

The DEFAULT and NONE values are obsolete for the nodes SoMaterialBinding and SoNormalBinding. The corresponding elements contain enum values for DEFAULT and NONE that make them the same as OVERALL for materials and PER_VERTEX_INDEXED for normals. If the code is compiled with -DIV_STRICT, these elements do not include values for DEFAULT and NONE, and any reference to them causes a compile-time error.

The element SoGLTextureQualityElement is obsolete. Use SoTextureQualityElement instead.

The following elements (and their OpenGL counterparts) are replaced by SoTextureImageElement (and its OpenGL counterpart):

Several elements that were responsible for material properties have been combined into two elements: SoLazyElement and its derived OpenGL version SoGLLazyElement.

Both elements are required, because some actions (for example callback actions) do not involve OpenGL. The following elements and their OpenGL counterparts are replaced by the lazy elements:

In Inventor 2.0, the SoElement base class automatically implemented override for all elements. Setting override on a node automatically caused an override flag to be set on every element that node overrode.

In Inventor 2.1, a node has to explicitly implement override. A new element, SoOverrideElement, has methods for getting and setting a bit for each element that can be overridden. Nodes must cooperate with one another by not doing anything if the bit for a particular element is set and by setting the bit for an element if the node's Override flag is set.

Many of the set methods on Inventor's built-in elements no longer take SoNode * parameters. In cases where the only reason for the SoNode * parameter was to test whether the node had its override set, the SoNode * parameter was removed. Elements that are subclasses of SoReplacedElement still take an SoNode * parameter in their set routines for cache dependencies.

This change improves performance and cache dependencies on override elements. Performance is improved because many nodes don't need override and they no longer have to pay for it. Cache dependencies are improved because the setting of the SoOverrideElement sets up the right dependencies.

If you created your own element and want to implement override behavior for it, you can either add and set override methods to the element (this is easier to implement) or implement another element that stores override information (this is better for caching).

The SoNormalGenerator class constructors take an argument that determines whether or not the polygons passed are in clockwise or counterclockwise order. Inventor now correctly generates normals for built-in shapes when the SoShapeHints node sets the vertex ordering to CLOCKWISE.

You don't have to change extender shapes that use SoNormalBundle to generate normals for them. You do have to modify extender shapes that use the SoNormalGenerator class directly to get the vertex ordering out of the ShapeHintsElement and pass TRUE or FALSE to the SoNormalGenerator constructor.

Inventor 2.1 has a new, more efficient mechanism for managing the material state during scene traversal. This section first discusses the new SoLazyElement and SoGLLazyElement, then provides instructions for converting GLRender() methods that use the lazy elements.

For backward compatibility, the material state of a shape can be managed (as in Inventor 2.0) by use of SoMaterialBundle. You have to set up the GLRender() method of the shape as follows:

For correct use of the material bundle, there should not be a push() or pop() of state between mb.sendFirst() and the invocation of the destructor, for example, consider the following code fragment:

beginSolidShape(action)
{//Scope material bundle
   SoMaterialBundle mb; 
   ...
}
endSolidShape(action);

Do not, for example, invoke SoShape::endSolidShape() until after the end of the scope of the material bundle because it pops the state, for example:

{//Don't do it this way
 SoMaterialBundle mb; 
 beginSolidShape(action)
 ...
 endSolidShape(action)
}

If an Inventor 2.1 shape consists of lines and/or points, you must implement a getBoundingBox() method that calls first the parents method and then:

SoBoundingBoxCache::setHasLinesOrPoints(action -> getState())

See “Getting a Bounding Box” for more detailed information.