OpenGL Performer allows you to interact with an abstract object (a representation or rep) and treat rendering as a separate operation. A simple example of a rep is a sphere, defined by a radius and a center. After defining a sphere, you can implement how it is rendered in several ways: by tessellating, by a sphere-specific draw routine, or conceivably by hardware. Member functions of geometric-primitive classes allow you to implement the most appropriate way of rendering. The fundamental rendering step of tessellating a representation is discussed in Chapter 11, “Rendering Higher-Order Primitives: Tessellators”.

NURBS curves and surfaces are included in the set of OpenGL Performer reps. OpenGL also has these, but OpenGL Performer NURBS have two advantages:

See Chapter 10, “Creating and Maintaining Surface Topology”.

The classes pfRVec2, pfRVec3, and pfRVec4 define two-, three-, and four-dimensional vectors, and include common operations of vector algebra such as addition, scalar multiplication, cross products, and so on. See the header file Performer/pr/pfLinMath.h for a list of operations defined for each vector.

The classes pfRVec2, pfRVec3, pfRVec4 and pfRMatrix are composed of either single- or double-precision values based on the PF_REAL_IS_DOUBLE #define. Currently, PF_REAL_IS_DOUBLE is set to 0. Hence, all pfRVecs as well as pfRMatrix and the pfReal type are defined as single-precision elements. It is important to use these new types (which are essentially #define statemtents) so that you may change to double- or arbitrary-precision versions of these elements when this functionality is enabled in OpenGL Performer.

One more type, pfBool, has also been added to the repertoire of types for OpenGL Performer and it always maps to the value of a 32-bit integer, regardless of the value of the PF_REAL_IS_DOUBLE #define, which can be found in Performer/pf.h.

In addition, pfLoop has been defined as a 32-bit integer and can take on one of the following values:

The pfScalar class is the base class for defining scalar functions; it allows you to conveniently read and write functions. The class provides a virtual evaluation method.

class pfScalar : public pfObject
{ public:
// Creating and destroying
pfScalar();
virtual ~pfScalar();
virtual pfReal eval(pfReal u) = 0;
}; 

class pfCompositeScalar : public pfScalar
{ public:
// Creating and destroying
pfCompositeScalar( );
pfCompositeScalar(pfScalar *outFun, pfScalar *inFun);
virtual ~pfCompositeScalar();

// Accessor functions
pfScalar *getOutF() 
pfScalar *getInF() 
void      setOutF(pfScalar *outF);
void      setInF (pfScalar *inF);

pfReal eval(pfReal t);

class pfPolyScalar : public pfScalar
{
public:
    // Creating and destroying
pfPolyScalar( void );
pfPolyScalar( int degree, pfReal* coef); 
virtual ~pfPolyScalar();
    // Accessor functions
void set( int degree, pfReal* coef);
int getDegree() 
pfReal getCoef( int i) 
    // Evaluators
pfReal eval(pfReal u);
};

Each geometric primitive is defined with respect to its own coordinate system. The elementary definition of an object gives a particular orientation and location with respect to the origin. This reference frame can, in turn, be manipulated by a pfDCS to place it in a scene or manipulate it.

The base class for higher-order primitives has methods that allow you to locate and orient a primitive with respect to its own reference frame. These methods make insertion of pfDCS nodes whenever you want to define the location or orientation of an object or to change the shape of an object unnecessary.

The location is defined by an pfRVec2 or pfRVec3, and the orientation is controlled by a 3 x 3 matrix, held in the class pfRMatrix. If the matrix is not a rotation matrix, you can change the shape of an object, for example, you can distort a sphere into an ellipsoid.

The class has the following main methods:

class pfRep : public pfGeode
{
public:
pfRep( );
virtual ~pfRep( );

// Accessor functions
void setOrigin( const pfRVec3&  org );
void setOrient( const pfRMatrix& mat );

void getOrigin(pfRMatrix& mat );
void getOrient(pfRVec3& org );
};

pfRep's subclasses typically include evaluator methods to determine coordinates of points, tangents, and normals. If you do not want the values corresponding to the default position, do not call these methods before you use setOrient() and setOrigin() to locate an pfRep. Thus, for example, when defining points on a circle, first set the center and the radius, then call setOrient() to set the orientation, and then evaluate points.

Planar curves consist of sets of points, described by two-dimensional vectors, pfRVec2s. They are parameterized by the pfReal variable t; as t varies, a point “moves” along the curve. t can be thought of as the amount of time that has passed as a point moves along the curve. Or, t can measure the distance traveled.

More precisely, each component of a point on the curve is a function of t, which lies in the parameter interval (t₀, t₁) on the real line. Points on the curve are described by a pair of functions of t: (x(t), y(t)).

Figure 9-2. Parametric Curve: Parameter Interval (0,1).

Classes derived from pfCurve2d inherit a set of evaluator functions which, for a given value of t, evaluate a point on the curve, the tangent and normal vectors at the point, and the curvature. Naturally, the base-class evaluator that locates points on the curve is a pure virtual function.

To evaluate tangent and normal vectors at a point, pfCurve2d provides virtual functions that, by default, use finite-central-difference calculations. To compute the tangent to the curve at p[t], a point on the curve, the tangent evaluator function takes the vector connecting two “nearby” points on the curve, p[t+Dt] - p[t-Dt] where Δτ is “small,” and divides by 2Δτ. Similarly, a finite-central-difference calculation of the normal vector uses the difference between two nearby tangent vectors: n[t] = (t[t+Dt] -t[t-Dt])/2Δτ.

class pfCurve2d : public pfRep
{
public:
// Creating and destroying
pfCurve2d( );
pfCurve2d( pfReal beginT, pfReal endT  );

virtual ~pfCurve2d();

// Accessor functions
void setBeginT( const pfReal beginT );
void setEndT( const pfReal endT );

pfReal getBeginT();
pfReal getEndT();

pfRVec2 getBeginPt();
pfRVec2 getEndPt();

pfRVec2 getBeginTan();
pfRVec2 getEndTan();

void setClosed( const pfLoop loopVal );
pfLoop getClosed();

void  setClosedTol( const pfReal tol );
pfReal getClosedTol() const;

// Evaluators
virtual void evalPt(    pfReal t, pfRVec2 &pnt ) = 0;
virtual void evalTan(   pfReal t, pfRVec2 &tan );
virtual void evalNorm(  pfReal t, pfRVec2 &norm );
virtual void evalCurv(  pfReal t, pfReal *curv );
virtual void eval(      pfReal t, pfRVec2 &pnt, 
                                  pfRVec2 &tan, 
                                  pfReal *curv, 
                                  pfRVec2 &norm );
};

Parametric lines in the plane are defined by beginning and ending points. The parameterization is such that as t varies from t1 to t2, a point on the line “moves,” at a uniform rate, from the beginning to the ending point.

Figure 9-3. Line in the Plane Parameterization

class pfLine2d : public pfCurve2d
{
public:
// Creating and destroying
pfLine2d();
pfLine2d( pfReal x1, pfReal y1, pfReal t1,
          pfReal x2, pfReal y2, pfReal t2 );
virtual ~pfLine2d();

// Accessor functions
void setPoint1( pfReal x1, pfReal y1, pfReal t1 ) ;
void setPoint2( pfReal x2, pfReal y2, pfReal t2 ) ;
void getPoint1( pfReal *x1, pfReal *y1, pfReal *t1 ) const;
void getPoint2( pfReal *x2, pfReal *y2, pfReal *t2 ) const;
// Evaluators
void evalPt(   pfReal t, pfRVec2 &pnt );
};

Use the class pfCircle2d to define a parametric circle in the plane. The parameterization is such that t is the angular displacement, in radians, in a counterclockwise direction from the X axis. Figure 9-4 illustrates the parameterization of the circle.

Figure 9-4. Circle in the Plane Parameterization

class pfCircle2d : public pfCurve2d
{
public:
    // Creating amd destroying
pfCircle2d();
pfCircle2d( pfReal rad, pfRVec2 *org );
virtual ~pfCircle2d();
    // Accessor functions
void   setRadius( pfReal rad ) ;
pfReal getRadius() const;
    // Evaluator
void evalPt(   pfReal t, pfRVec2 &pnt );
void evalTan(  pfReal t, pfRVec2 &tan );
void evalCurv( pfReal t, pfReal *curv );
void evalNorm( pfReal t, pfRVec2 &norm );
void eval(     pfReal t, 
               pfRVec2 &pnt, 
               pfRVec2 &tan, 
               pfReal *curv,
               pfRVec2& norm );
};

The class pfSuperQuadCurve2d provides methods to define a generalization of a circle that, when used for constructing a swept surface, is convenient for generating rounded, nearly square surfaces, or surfaces with sharp cusps (see “Swept Surfaces”). Two examples of superquadrics appear in repTest.

The position along the curve is specified by an angle from the x axis, in the same as for an pfCircle2d. The shape of the curve is controlled by a second parameter.

A superquadric is the set of points (x,y) given by the following equation that clearly expresses the relationship to the equation of a circle:

The above equation can be written in a parametric form:

The family of curves generated by these equations as the quantity α varies can be described as follows (see Figure 9-5).

Four points are always on the curve for any value of a: (\ξβ1 ρ, 0) and (0, \ξβ1 ρ).

class pfSuperQuadCurve2d : public pfCurve2d
{
public:
// Creating and destroying
pfSuperQuadCurve2d();
pfSuperQuadCurve2d( pfReal radius, 
                    pfRVec2 *origin,
                    pfReal exponent );
virtual ~pfSuperQuadCurve2d();

// Accessor functions
void   setRadius( pfReal _radius );
pfReal getRadius() const;

void   setExponent( pfReal _exponent );
pfReal getExponent() const;

// Evaluator
void evalPt(   pfReal t, pfRVec2 &pnt );
};

A spline is a mathematical technique for generating a single geometric object from pieces. An advantage of breaking a curve into pieces is greater flexibility when you have many points controlling the shape: changes to one piece of the curve do not have significant effects on remote pieces. To define a spline curve for a range of values for the parameter t, say from 0 to 3, you “tie” together pieces of curves defined over intervals of values for t. For example, you might assign curve pieces to the three intervals 0 to 1, 1 to 2, and 2 to 3. The four points in the set of parameters, 0, 1, 2, and 3, define the endpoints of the intervals and are called knots.

A Hermite-spline curve is a curve whose segments are cubic polynomials of the parameter t, where the coefficients of the polynomials are determined by the position and tangent to the curve at each knot point. Thus the curve passes through each of a set of specified points with a specified tangent vector. The set of knot points must be increasing values of the parameter t.

Figure 9-6. Hermite Spline Curve Parameterization

class pfHsplineCurve2d : public pfCurve2d
{
public:
// Creating and destroying
pfHsplineCurve2d();
virtual ~pfHsplineCurve2d();

// Accessor functions  
void setPoint(   int i, const pfRVec2 &p );
void setTangent( int i, const pfRVec2 &tng );
void setKnot(    int i, pfReal t );

int getKnotCount() const;
pfRVec2* getPoint( int i );
pfRVec2* getTangent( int i );
pfReal  getKnot( int i );

// Evaluator
virtual void evalPt( pfReal t, pfRVec2 &pnt );
};

The acronym NURBS stands for “nonuniform rational B-splines.” NURBS define a set of curves and surfaces that generalizes Bezier curves. Both NURBS curves and Bezier curves are “smooth” curves that are well suited for CAD design work. They are essentially determined by a set of points that controls the shape of the curves, although the points do not lie on the curves.

Because NURBS properties are not widely known, a discussion of their features precedes details of how to create instances of them. The discussion is necessarily brief and is intended to provide the minimum amount of information needed to start using OpenGL Performer NURBS classes.

This general discussion of NURBS is presented in the following sections:

Equation Used to Calculate a NURBS Curve

The equation that defines the NURBS curve is

Alternative Equation for a NURBS Curve

If you have a surface developed from the alternative expression for a NURBS surface:

you must change the coordinates of the control points to get the same surface from OpenGL Performer; you convert the coordinates of the control points from (x,y,w) to (wx,wy,w).

The class pfNurbCurve2d defines a nonuniform rational B-spline curve in the plane, the simplest NURBS object provided by OpenGL Performer.

class pfNurbCurve2d : public pfCurve2d
{
public:
// Creating and destroying
pfNurbCurve2d( );
pfNurbCurve2d( pfReal tBegin, pfReal tEnd );
virtual ~pfNurbCurve2d( );

// Accessor functions
void setControlHull(     int i, const pfRVec2 &p );
void setControlHull(     int i, const pfRVec3 &p );
void setWeight(          int i, pfReal w  );
void setKnot(            int i, pfReal t  );
void setControlHullSize( int s            );

pfRVec2* getControlHull( int i );
pfReal  getWeight( int i );
int     getControlHullSize( );
int     getKnotCount( );
pfReal  getKnot( int i );
int     getOrder( );

void removeControlHullPnt(int i);
void removeKnot(int i);

// Evaluator
virtual void evalPt( pfReal t, pfRVec2 &pnt );
};

A piecewise polynomial curve consists of an array of polynomial curves. Each polynomial curve is a polynomial mapping from t to UV plane, where the domain is a subinterval of [0,1]. The polynomial coefficients are set by setControlHull().

Notice that an pfPieceWisePolyCurve2d is a subclass of pfCurve2d. The domain of a pfPieceWisePolyCurve2d is defined to be [0, n] where n is the number of pieces.

If reverse is 0, then for any given t in [0, n], its corresponding uv is evaluated in the following way: The index of the piece that corresponds to t is floor(t), and the polynomial of that piece is evaluated at w1 + (t-floor(t)) * (w2-w1) to get the (u,v), where [w1, w2] is the domain interval (set by setLimitParas()) of this piece.

If reverse is 1, then for any given t in [0,n], we first transform t into n-t, then perform the normal evaluation (at n-t) as described in the preceding paragraph.

class pfPieceWisePolyCurve2d : public pfCurve3d
{
public:
// Creating and destroying
pfPieceWisePolyCurve2d ( );
virtual ~pfPieceWisePolyCurve2d ( );

//Accessor functions
void setControlHull ( int piece, int i, const pfRVec2& p);
pfRVec2& getControlHull ( int piece, int i);
void setLimitParas ( int piece, pfReal w1, pfReal w2);
void setReverse ( int _reverse);
pfRVec2& getLimitParas ( int piece);
int getReverse ( ) const;
int getPatchCount ( ) const;
int getOrder ( int piece);
virtual void evalPt ( pfReal t, pfRVec2& pnt);
virtual void evalBreakPoints ( pfParaSurface* sur);
};

The class pfDisCurve2d is the base class for making a discrete curve from line segments connecting a sequence of points in the plane. Because pfDisCurve2d is not derived from pfCurve2d, it does not inherit that class's finite difference functions for calculating derivatives, therefore, pfDisCurve2d includes member functions that calculate arc length, tangents, principal normals, and curvatures using finite central differences. Figure 9-7 illustrates the definition of the curve by a set of points.

Figure 9-7. Discrete Curve Definition

class pfDisCurve2d : public pfRep
{
public:
// Creating and destroying
pfDisCurve2d( void );
pfDisCurve2d( int nPoints, pfReal *points );

virtual ~pfDisCurve2d( void );

// Accessor functions
void set (int nPoints, pfReal* points);
pfRVec2 getBeginPt() const;
pfRVec2 getEndPt() const;

pfLoop getClosed();
void   setClosed( pfLoop c );

void setPoint( int i, const pfRVec2& pnt ); 
pfRVec2 getPoint( int i) const;
int getPointCount(); const;
pfRVec2 getTangent(int i) const; 
pfRVec2 getNormal(int i) const; 
pfReal getCurvature(int i) const;

// Evaluators
void computeTangents( );
void computeNormals( );
void computeCurvatures( );
void computeDerivatives( );
};

The base class for lines in space, pfLine3d, is essentially the same as pfLine2d, discussed in “Lines in the Plane”. The main differences are due to the need to manage three-dimensional vectors. Thus all vector variables are pfRVec3 and the constructor takes six variables to define the endpoints of the line.

The default orientation of the curve is identical to that for the planar curve pfLine2d; you can translate and rotate the line in three-dimensional space with the methods setOrigin() and setOrient() inherited from pfRep.

The class pfCircle3d defines a parametric circle with an arbitrary location and orientation in space. The parameterization of the circle, before you change its location or orientation, is such that t is the angular displacement, in radians, in a counterclockwise direction from the x axis.

The class declaration for pfCircle3d is identical to that for pfCircle2d, discussed in “Circles in the Plane”, except for the changes from pfRVec2 to pfRVec3. The member functions perform the same operations. For more information, see the discussion in the section “Circles in the Plane”.

If the matrix you use to orient an pfCircle3d does not correspond to a rotation about an axis—that is, the matrix is not orthonormal— you not only change the tilt of the plane in which the circle lies but also change the radius, and may distort the circle into an ellipse. .

The class pfSuperQuadCurve3d provides methods to define a superquadric in space (see “Superquadric Curves: pfSuperQuadCurve2d”). The class declaration is identical to that for pfSuperQuad2d except that position on the curve is defined by an pfRVec3.

The default orientation of the curve is identical to that for the planar curve pfSuperQuad2d; you can translate and rotate the curve in three-dimensional space with the methods setOrigin() and setOrient() inherited from pfRep.

The class pfHsplineCurve3d provides methods to define a Hermite spline curve in space. The definition of the curve is the same as that for a Hermite spline curve in the plane, discussed in “Hermite-Spline Curves in the Plane”. The class declaration is the same as that for pfHsplineCurve2d, but the position and tangent vectors are pfRVec3s.

The basic properties of NURBS are discussed in the section “NURBS Overview”. In an effort to keep things as simple as possible, the discussion in that section has a bias toward curves in the plane. But the principles and control parameters are, with one difference, the same for NURBS curves in space.

The difference is that control points for NURBS curves in space can be anywhere in space instead of being restricted to a plane. The section “Examples of NURBS Curves” in Chapter 8 of The Inventor Mentor presents illustrations of NURBS curves in space, along with their control parameters.

The class pfNurbCurve3d is the base class for NURBS curves in space. Its class declaration is practically identical to that for pfNurbCurve2d but all occurrences of pfRVec2 are changed to pfRVec3. In addition, the vector argument of setControlHull() can be an pfRVec3, if you just want to specify control point locations, or an pfRVec4, if you want to append weighting information as a fourth component. See the discussion in the section “NURBS Curves in the Plane”.

A planar curve in the u-v plane describes a curve on the surface, given a parameterized surface (see the section “Parametric Surfaces”). Each point on the curve in the parameter plane is “lifted up” to the surface. Such curves are known as composite curves because they are described mathematically as the composition of the function describing the curve and the function describing the surface. The edge of a surface defined by a trim curve is a composite curve.

pfCompositeCurve3d is the base class for composite curves. This class is useful for defining trim curves and surface silhouettes in the parametric surface's coordinate system.

class pfCompositeCurve3d : public pfCurve3d
{
public:
// Creating and destroying
pfCompositeCurve3d( );
pfCompositeCurve3d( pfParaSurface *sur, pfCurve2d *cur );
virtual ~pfCompositeCurve3d( );

// Accessor functions
void set( pfParaSurface *sur, pfCurve2d *cur );
pfParaSurface* getParaSurface() const;
pfCurve2d* getCurve2d() const;

// Evaluator
void evalPt( pfReal u, pfRVec3 &pnt );
};

The class pfDisCurve3d is the base class for making a discrete curve of line segments connecting a sequence of points in space. The class declaration for pfDisCurve3d is identical to that for pfDisCurve2d, discussed in “Discrete Curves in the Plane”, but pfRVec2 changes to pfRVec3. The member functions perform the same operations.

One application of an pfDisCurve3d and pfHsplineCurve3d is to use them to interactively specify routing for tubing. These are the operations to perform:

To locate a point on a parametric surface, you need two parameters, referred to as u and v in OpenGL Performer. The set of u and v values that describe the surface are known as the parameter space, or coordinate system, of the surface (see Figure 9-8).

More precisely, the coordinates of the points in space that define a parametric surface are described by a set of three functions of two parameters: (x(u,v), y(u,v), z(u,v)).

Well-known examples of a parametric surface are a sphere or a globe. On a globe you can locate points with two parameters: latitude and longitude. The rectangular grid of latitude and longitudes is the coordinate system that describes points on the globe.

Figure 9-8. Parametric Surface: Unit-Square Coordinate System

To define the extent of a parametric curve, pick an interval. For accurate trimming of a parametric surface, you need more complex tools. You are likely to need:

OpenGL Performer keeps the trim loop side on the left as you look down on the u-v plane while a point moves along the curve in the direction of increasing t; you can hold on to the surface with your left hand as you go along the trim loop. Thus a clockwise loop removes a hole; a counterclockwise loop keeps the enclosed region and eliminates everything outside. Do not create a trim loop that crosses itself like a figure eight.

OpenGL Performer allows you to maintain curves to define the edges of a surface. These curves are pfCurve2d objects defined in the u-v plane that are “lifted” to the surface by the parameterization. The main use of these curves is to eliminate a portion of the surface on one side of the curve. The name of a curve in the coordinate system that is used to define (possibly a piece of) such a surface edge is a trim curve. One or more joined trim curves form a sequence called a trim loop. To be of use, trim curves should form a closed loop or reach the edges of the coordinate system for the surface. Figure 9-9 illustrates trim loops and their effect on a surface.

Figure 9-9. Trim Loops and Trimmed Surface: Both Trim Loops Made of Four Trim Curves

An pfEdge defines a trim curve in u, v space. pfEdge holds information about a surface's adjacency. Each pfEdge identifies an pfBoundary, which the class pfTopo uses to keep track of surface connectivity, and continuous and discrete versions of the trim curve associated with the boundary. The members of an pfEdge are set by the toplogy building tools; the methods of pfEdge access the members. Topology building and the classes pfTopo and pfBoundary are discussed further in Chapter 10, “Creating and Maintaining Surface Topology”.

The information held in pfEdge allows tessellators to determine whether a set of vertices has already been developed for points shared with other surfaces. You can also find other surfaces that have the same edge or trim-curve endpoint as that defined by a given trim curve.

The set*() methods are mainly used when reading surface data from a file and creating OpenGL Performer data structures.

class pfEdge : public pfObject
{
public:
// Creating and destroying
pfEdge();
~pfEdge();

pfCurve2d *getContCurve();
void setContCurve(pfCurve2d *c);

pfDisCurve2d *getDisCurve();
void setDisCurve( pfDisCurve2d *d);

int getBoundary();

void setBoundaryDir( int dir );
int getBoundaryDir();
};

pfParaSurface is the base class for parametric surfaces in OpenGL Performer. As for the base classes pfCurve2d and pfCurve3d, pfParaSurface includes a pure virtual function to evaluate points on the surface and default evaluator functions that calculate derivatives using finite central differences. The surface normal at a point is the cross product of the partial derivatives.

For parametric curves whose extent is defined by the interval of values for t, the extent of an pfParaSurface is, initially, defined by all the points in its parameter space.

class pfParaSurface : public pfRep
{
public:
// Creating and destroying
pfParaSurface( pfReal _beginU = 0, pfReal _endU = 1, 
               pfReal _beginV = 0, pfReal _endV = 1,
               int    _topoId = 0, int    _solid_id = -1 );

virtual ~pfParaSurface();

// Accessor functions
void setBeginU( pfReal u );
void setEndU(   pfReal u );
void setBeginV( pfReal v );
void setEndV(   pfReal v );
void setSolidId( int solidId);
void SetTopoId( int topoId);
void setSurfaceId (int surfaceId);
pfReal getBeginU() const;
pfReal getEndU() const; 
pfReal getBeginV() const;
pfReal getEndV() const;

int     getTrimLoopCount();
pfLoop  getTrimLoopClosed( int loopNum );
int     getTrimCurveCount( int loopNum );
pfEdge* getTrimCurve( int loopNum, int curveNum );

int     getTopoId();
int     getSolidId();
int     getSurfaceId();
  
void setHandednessHint( pfbool _clockWise );
pfbool getHandednessHint() const;
  
pfGeoState* getGState( ) const;
int setGState( pfGeoState *gState );

void insertTrimCurve( int loopNum, pfCurve2d *c, pfDisCurve2d *d );

// Explicit add a trim curve to a trim loop
void addTrimCurve(int loopNum, pfCurve2d *c, pfDisCurve2d *d );
void setTrimLoopClosed(  int loopNum, pfLoop closed );

// Surface evaluators
virtual void evalPt(   pfReal u, pfReal v, pfRVec3 &pnt ) = 0;
virtual void evalDu(   pfReal u, pfReal v, pfRVec3 &Du );
virtual void evalDv(   pfReal u, pfReal v, pfRVec3 &Dv );
virtual void evalDuu(  pfReal u, pfReal v, pfRVec3 &Duu );
virtual void evalDvv(  pfReal u, pfReal v, pfRVec3 &Dvv );
virtual void evalDuv(  pfReal u, pfReal v, pfRVec3 &Duv );
virtual void evalNorm( pfReal u, pfReal v, pfRVec3 &norm );

// Directional derivative evaluators
virtual void evalD( pfReal u, pfReal v, pfReal theta, pfRVec3 &D );
virtual void evalDD( pfReal u, pfReal v, pfReal theta, pfRVec3 &DD );

virtual void eval( pfReal u, pfReal v,
pfRVec3 &p,            // The point
pfRVec3 &Du,           // The derivative in the u direction
pfRVec3 &Dv,           // The derivative in the v direction
pfRVec3 &Duu,          // The 2nd derivative in the u direction
pfRVec3 &Dvv,          // The 2nd derivative in the v direction
pfRVec3 &Duv,          // The cross derivative
pfReal &s,            // Texture coordinates
pfReal &t  );

void clearTessallation();
};

The simplest parametric surface is a plane. The class pfPlaneSurface defines a plane by two parameter intervals and three points that define the two coordinate directions. Figure 9-10 illustrates the parameterization of an pfPlaneSurface.

Figure 9-10. Plane Parameterization

class pfPlaneSurface : public pfParaSurface
{
public:
// Creating and destroying
pfPlaneSurface();
pfPlaneSurface( pfReal x1, pfReal y1, pfReal z1, pfReal u1, pfReal v1,
         pfReal x2, pfReal y2, pfReal z2, pfReal u2,
         pfReal x3, pfReal y3, pfReal z3, pfReal v3 );
virtual ~pfPlaneSurface();

// Accessor functions
void setPoint1( pfReal x1, pfReal y1, pfReal z1, pfReal u1, pfReal v1);
void setPoint2( pfReal x2, pfReal y2, pfReal z2, pfReal u2 );
void setPoint3( pfReal x3, pfReal y3, pfReal z3, pfReal v3 );
 
void getPoint1( pfReal *x1, pfReal *y1, pfReal *z1, 
                pfReal *u1, pfReal *v1 );
void getPoint2( pfReal *x2, pfReal *y2, pfReal *z2, pfReal *u2 );
void getPoint3( pfReal *x3, pfReal *y3, pfReal *z3, pfReal *v3 );

// Evaluators
void evalPt( pfReal u, pfReal v, pfRVec3 &pnt );
void evalDu( pfReal u, pfReal v, pfRVec3 &Du );
void evalDv( pfReal u, pfReal v, pfRVec3 &Dv );
void evalNorm( pfReal u, pfReal v, pfRVec3 &norm );
}

The surface of the sphere is parameterized by angles, in radians, for latitude and longitude; v corresponds to longitude, u to latitude. Figure 9-11 illustrates the parameterization of an pfSphereSurface.

Figure 9-11. Sphere Parameterization

class pfSphereSurface : public pfParaSurface
{
public:
// Creating and destroying
pfSphereSurface( );
pfSphereSurface( pfReal radius );
virtual ~pfSphereSurface( );
      
// Accessor functions
void setRadius( pfReal radiusVal );
pfReal getRadius( ) const;

// Evaluators
void evalPt(   pfReal  u, pfReal v, pfRVec3 &pnt );
void evalNorm( pfReal  u, pfReal v, pfRVec3 &norm );
}

x = radius * cos(u) * sin(v)
y = radius * sin(u) * sin(v)
z = radius * cos(v)

pfSphereSurface *sphere = new pfSphereSurface( 3 );

// under certain conditions, a trim curve is added that keeps only the // portion of the surface above a circle 
if ( nVersions <= 0 )
{
pfCircle2d  *trimCircle2d = 
                   new pfCircle2d( 1.0, new pfRVec2(M_PI/2.0,M_PI) );
sphere->addTrimCurve( 0, trimCircle2d );
}
setUpShape( sphere, PF_XDIST*numObject++, Y, PF_VIEWDIST );

The pfCylinderSurface class provides methods for describing a cylinder.

A cylinder can be defined geometrically as the surface in space that is swept by moving a circle along an axis that is perpendicular to the plane of the circle and passes through the center of the circle.

The parameterization of an pfCylinderSurface is as follows: u represents the position on the circle and that v represents the position along the axis.

Figure 9-12. Cylinder Parameterization

class pfCylinderSurface : public pfParaSurface
{
public:
// Creating and destroying
pfCylinderSurface( void );
pfCylinderSurface( pfReal radius, pfReal height );
virtual ~pfCylinderSurface();

// Accessor functions
void setRadius( pfReal radiusVal ) ;
void setHeight( pfReal heightVal );

pfReal getRadius( ) const;
pfReal getHeight( ) const;

// Evaluators
void evalPt(   pfReal  u, pfReal v, pfRVec3 &pnt );
void evalNorm( pfReal  u, pfReal v, pfRVec3 &norm );
};

The pfTorusSurface class provides methods to describe a torus. Figure 9-13 illustrates a torus, and how it is parameterized in pfTorusSurface.

A torus can be defined geometrically as the surface in space that is swept by moving a circle, the minor circle, through space such that its center lies on a second circle, the major circle, and the planes of the two circles are always perpendicular to each other, with the plane of the minor circle aligned along radii of the major circle. The parametrization of the surface is that u represents a position on the major circle and v represents a position on the minor circle.

Figure 9-13. Torus Parameterization

class pfTorusSurface : public pfParaSurface
{
public:
// Creating and destroying
pfTorusSurface( );
pfTorusSurface( pfReal majorRadius, pfReal minorRadius );
virtual ~pfTorusSurface();
      
// Accessor functions
void setMajorRadius(  pfReal majorRadiusVal );
void setMinorRadius( pfReal minorRadiusVal );
pfReal getMajorRadius( ) const;
pfReal getMinorRadius( ) const;

// Evaluators
virtual void evalPt(   pfReal  u, pfReal v, pfRVec3 &pnt );
virtual void evalNorm( pfReal  u, pfReal v, pfRVec3 &norm );
}

You can define a cone geometrically by sweeping a circle along an axis in a way similar to the way a cylinder is defined; however, as the circle is swept along the axis, the radius changes linearly with distance.

The parameterization of a point on an pfConeSurface is that u measures the angle, in radians, of the point on the circle, and that v measures the distance along the axis from the origin. To truncate a cone, yielding a frustum, adjust the value for v.

Figure 9-14. Cone Parameterization

class pfConeSurface : public pfParaSurface
{
public:
// Creating and destroying
pfConeSurface( void );
pfConeSurface( pfReal radius, pfReal height );
virtual ~pfConeSurface();
      
// Accessor functions
void setRadius( pfReal radius ) ;
void setHeight( pfReal height );
pfReal getRadius( ) const;
pfReal getHeight( ) const;

// Evaluators
void evalPt(   pfReal  u, pfReal v, pfRVec3 &pnt );
void evalNorm( pfReal  u, pfReal v, pfRVec3 &norm ); 
}

The class pfSweptSurface provides methods to describe a general swept surface. Three examples of swept surfaces have been presented: a cylinder, a torus, and a cone. In the first two cases a simple cross-section, a circle of constant radius, was swept along a path. For a cone, the radius of the circle varied according to a simple profile.

To describe a swept surface, you specify a path, a cross section, and a coordinate frame in which the graph of the cross section is drawn at each point on the path. The parameterization of the surface is that u denotes the position along the path and v denotes the position on the cross-section curve. You can also specify a  profile, which adjusts the size of the cross-section curve. Thus, for example, with a simple profile method you could generate a sphere from a straight-line path and a circular cross section. Figure 9-15 illustrates the feature of a swept surface.

Figure 9-15. Swept Surface: Moving Reference Frame and Effect of Profile Function

class pfSweptSurface : public pfParaSurface
{
public:
// Creating and destroying
pfSweptSurface( void );
pfSweptSurface( pfCurve3d *crossSection,
                pfCurve3d *_path,
                pfCurve3d *_t,
                pfCurve3d *_b,
                pfScalar  *_profile  );
virtual ~pfSweptSurface( );

// Accessor functions
void setCrossSection( pfCurve3d *_crossSection );
void setPath( pfCurve3d *_path );
void setT( pfCurve3d *_tng );
void setB( pfCurve3d *_b );
void setProf( pfScalar  *_profile );
pfCurve3d *getCrossSection() const;
pfCurve3d *getPath() const;
pfCurve3d *getT() const;
pfCurve3d *getB() const;
pfScalar  *getProf()const;

virtual void evalPt( pfReal u, pfReal v, pfRVec3 &pnt );
};

As a convenience, the class pfFrenetSweptSurface allows you to use the Frenet frame of the path to define the orientation vectors in a swept surface. The Frenet frame is defined by the three unit vectors derived from the tangent, the principal normal, and their cross product. This set of vectors facilitates orienting the cross section perpendicularly to the path at every point.

---

Note: The path for an pfFrenetSweptSurface must be at least a cubic to allow for the principal normal calculation, which requires a second derivative.

---

class pfFrenetSweptSurface : public pfSweptSurface
{
public:
// Accessor functions
pfFrenetSweptSurface( void );
pfFrenetSweptSurface( pfCurve3d *crossSection,
                      pfCurve3d *path,
                      pfScalar  *profile  );
virtual ~pfFrenetSweptSurface( );

// Accessor functions
void set( pfCurve3d *crossSection,
          pfCurve3d *path,
          pfScalar  *profile  );
};

// Scalar curve used by the swept surface primitive
static pfReal profile( pfReal t )
{
return 0.5*cos(t*5.0) + 1.25;
};
 
pfCircle3d  *cross = 
                    new pfCircle3d( 0.75, new pfRVec3( 0.0, 0.0, 0.0) );
pfCircle3d  *path  = 
                    new pfCircle3d( 1.75, new pfRVec3( 0.0, 0.0, 0.0) );
pfFrenetSweptSurface *fswept = 
                      new pfFrenetSweptSurface( cross, path, profile );
fswept->setHandednessHint( TRUE );

A ruled surface is generated from two curves in space, both parameterized by the same variable, u. A particular value of u specifies a point on both curves. A ruled surface is defined by connecting the two points with a straight line parameterized by v. The parameterization of the resulting surface is always the unit square in the UV plane, regardless of the parameterizations of the original curves.

Figure 9-16. Ruled Surface Parameterization

A bilinear interpolation of four points is perhaps the simplest example of a ruled surface, one for which the “curves” that define the surface are in fact straight lines. Thus, you connect two pairs of points in space with lines and then develop the ruled surface. For a bilinear interpolation, the parameterization by u and v is such that, if one of them is held constant, a point “moves” along the connecting straight line at a uniform speed as the other parameter is varied.

class pfRuledSurface : public pfParaSurface
{
public:
// Creating and destroying
pfRuledSurface();
pfRuledSurface( pfCurve3d *c1, pfCurve3d *c2 );
virtual ~pfRuledSurface();
// Accessor functions
void setCurve1( pfCurve3d *_c1 );
void setCurve2( pfCurve3d *_c2 );
pfCurve3d *getCurve1( ) const;
pfCurve3d *getCurve2( ) const;

// Evaluators
void evalPt(   pfReal  u, pfReal v, pfRVec3 &pnt );
};

A Coons patch is arguably the simplest surface you can define from four curves whose endpoints match and form a closed loop. Think of the four curves as defining the four sides of the patch, with one pair on opposite sides of the patch defining the top and bottom curves and the other pair defining the left and right curves (see Figure 9-17). The top and bottom curves are parameterized by u, and the left and right curves by v. Thus, u is the “horizontal” coordinate and v the “vertical” coordinate.

The patch is made by

Figure 9-17 illustrates the construction. To understand the result, notice that, after you add the two ruled surfaces, each side of the boundary of the resulting surface is the sum of the original bounding curve and the straight line connecting the bounding curve's endpoints. The straight line was introduced by the construction of the ruled surface that did not include the boundary curve. Subtracting the bilinear interpolation eliminates the straight-line components of the sum, leaving just the original four curves as the boundary of the resulting surface.

Figure 9-17. Coons Patch Construction

class pfCoonsSurface : public pfParaSurface
{
public:
pfCoonsSurface( );
pfCoonsSurface( pfCurve3d *right,   pfCurve3d *left,
         pfCurve3d *bottom,  pfCurve3d *top );
virtual ~pfCoonsSurface( );

// Accessor functions
void setRight(  pfCurve3d *right );
void setLeft( pfCurve3d *left );
void setBottom( pfCurve3d *bottom );
void setTop( pfCurve3d *top );

pfCurve3d* getTop() const;
pfCurve3d* getBottom() const;
pfCurve3d* getLeft() const;
pfCurve3d* getRight() const;

// Surface point evaluator
void evalPt( pfReal u, pfReal v, pfRVec3 &pnt );
};

Just as a NURBS curve consists of Bezier curves, a NURBS surface consists of Bezier surfaces. The set of control parameters is essentially the same for the curves and surfaces: a set of knots, a control hull, and a set of weights. However, for a NURBS surface, the knots form a grid in the coordinate system of the surface; that is, in the u-v plane, and the control hull is a grid of points in space that loosely defines the surface.

Understanding a Bezier surface helps you understand and use a NURBS surface. A Bezier surface is defined essentially as the surface formed by sweeping a Bezier cross section curve through space, along a path defined by a Bezier curve. But, unlike an pfSweptSurface, the shape of the cross-section can be changed.

You define a Bezier surface as follows:

A NURBS surface joins Bezier surfaces in a smooth way, similar to NURBS curves joining Bezier curves. The class pfNurbSurface provides methods to describe a NURBS surface.

class pfNurbSurface : public pfParaSurface
{
public:
// Creating and destroying
pfNurbSurface( void );
virtual ~pfNurbSurface( );

// Accessor functions
void setControlHull( int iu, int iv, const pfRVec3 &p );
void setControlHull( int iu, int iv, const pfRVec4 &p );
void setWeight( int iu, int iv, pfReal w ); 
void setUknot( int iu, pfReal u );
void setVknot( int iv, pfReal v );
void setControlHullUSize( int s );
void setControlHullVSize( int s );

// Get the same parameters
pfRVec3& getControlHull( int iu, int iv) ;
int     getControlHullUSize( void );
int     getControlHullVSize( void );
pfReal  getWeight( int iu, int iv)
pfReal  getUknot( int iu);
pfReal  getVknot( int iv);
int     getUknotCount( void );
int     getVknotCount( void );
int     getUorder( void ) ;
int     getVorder( void ) ;
void    removeControlHullElm(int ui, int iv);
void    removeUknot(int iu);
void    removeVknow(int iv);
void    flipUV();

// Evaluator
virtual void evalPt(   pfReal u, pfReal v, pfRVec3 &pnt );
virtual void evalDu(   pfReal u, pfReal v, pfRVec3 &Du );
virtual void evalDv(   pfReal u, pfReal v, pfRVec3 &Du );
virtual void evalNorm( pfReal u, pfReal v, pfRVec3 &norm );
};

Equation Used to Calculate a NURBS Surface

Indexing is determined by the following equation that OpenGL Performer uses to calculate a NURBS surface (the index i corresponds to iu in the API, and j corresponds to iv):

Alternative Equation for a NURBS Surface

A NURBS surface can also be developed from the following alternative expression:

For this case, you must change the coordinates of the control points to get the same surface from OpenGL Performer. You convert the coordinates of the control points from (x,y,z,w) to (wx,wy,wz,w).

int i, j;

pfNurbSurface *nurb = new pfNurbSurface;

// Control hull dimensions
#define USIZE 4
#define VSIZE 5

// Set up the control hull size because we know a priori how big
// the nurb is.  The next two lines are used for space
// efficiency but are functionally unnecessary.
nurb->setControlHullUSize(USIZE);
nurb->setControlHullVSize(VSIZE);

// Make the control hull be an oscillating grid
for ( i = 0; i < VSIZE; i++ )
{
pfReal y = i/(float)(VSIZE - 1) * 2*M_PI - M_PI;
      
for ( j = 0; j < USIZE; j++ )
{
pfReal x = j/(float)(USIZE - 1) * 2*M_PI - M_PI;
pfReal val = 6*pow( cos(sqrt(x*x + y*y)), 2.0); 

// Make the control hull a box, j maps to u and i maps to v
nurb->setControlHull( i, j, pfRVec3( x, y, val));

// Add the weights
nurb->setWeight( i, j, 1.0 );
}
}

// Add the knot points
nurb->setUknot( 0,  0.0 );
nurb->setUknot( 1,  0.0 );
nurb->setUknot( 2,  0.0 );
nurb->setUknot( 3,  0.0 );
nurb->setUknot( 4,  1.0 );
nurb->setUknot( 5,  1.0 );
nurb->setUknot( 6,  1.0 );
nurb->setUknot( 7,  1.0 );

nurb->setVknot( 0,  0.0 );
nurb->setVknot( 1,  0.0 );
nurb->setVknot( 2,  0.0 );
nurb->setVknot( 3,  0.0 );
nurb->setVknot( 4,  1.0 );
nurb->setVknot( 5,  1.0 );
nurb->setVknot( 6,  1.0 );
nurb->setVknot( 7,  1.0 );

// Only trim reps in the first row
if ( nVersions <= 0 )
{
// Add a super quadric trim curve 
pfSuperQuadCurve2d  *trimCircle0 = new pfSuperQuadCurve2d( 0.25, new pfRVec2(0.25, 0.50), 2.0 );
nurb->addTrimCurve( 0, trimCircle0, NULL );

// make a 4-th order nurb trim curve
pfNurbCurve2d *l = new pfNurbCurve2d;

l->setKnot(0,0.0);
l->setKnot(1,0.0);
l->setKnot(2,0.0);
l->setKnot(3,0.0);
l->setKnot(4,1.0);
l->setKnot(5,1.0);
l->setKnot(6,1.0);
l->setKnot(7,1.0);
l->setControlHull(0,pfRVec2(0.50,0.50));
l->setControlHull(1,pfRVec2(0.90,0.10));
l->setControlHull(2,pfRVec2(0.90,0.90));
l->setControlHull(3,pfRVec2(0.50,0.50));

nurb->addTrimCurve( 1, l, NULL  );
}

Hermite-spline surfaces interpolate a grid of points; that is, they pass through the set of specified points under the constraint that you supply the tangents at each point in the u and v directions and the mixed partial derivative at each point. This surface definition is the natural generalization of Hermite-spline curves, discussed in “Hermite-Spline Curves in the Plane”.

Figure 9-19. Hermite Spline Surface With Derivatives Specified at Knot Points

Hermite-spline surfaces are made of Hermite patches (see Figure 9-19). A bicubic Hermite patch expands the definition of a bilinear interpolation to include specification of first derivatives and mixed partial derivatives of the surface at each of the four corners. The adjective “bicubic” in the name of the patches refers to the mathematical definition, which includes products of the cubic Hermite polynomials that define a Hermite-spline curve.

An advantage of including the derivatives to constrain the surface is that it is simple to combine the patches into a smooth composite surface, that is, into a Hermite-spline surface.

class pfHsplineSurface : public pfParaSurface
{
public:
// Creating and destroying
pfHsplineSurface();
pfHsplineSurface( pfReal *_p, 
                  pfReal *_tu,  pfReal *_tv, pfReal *_tuv, 
                  pfReal *_uu, pfReal *_vv, 
                  int uKnotCount, int vKnotCount );
virtual ~pfHsplineSurface();

// Accessor functions
pfRVec3& getP( int i, int j );
pfRVec3& getTu( int i, int j );
pfRVec3& getTv( int i, int j );
pfRVec3& getTuv( int i, int j );
pfReal  getUknot( int i );
pfReal  getVknot( int j );
int     getUknotCount();
int     getVknotCount();
pfBool  getCylindrical();

void setAll( pfReal *p, 
             pfReal *tu,
             pfReal *tv, 
             pfReal *tuv,
             pfReal *uu,
             pfReal *vv,
             int uKnotCount,
             int vKnotCount );
void setCylindrical( pfBool cylinderical );

// Surface point evaluator
void evalPt( pfReal u, pfReal v, pfRVec3 &pnt );
};

OpenGL Performer uses mesh faces and its vertices to describe a mesh, which in turn describes the topology of an object. The high-level class pfMeshFace encapulsates a face. Each face contains the following:

A pfMeshVertex is a high-level OpenGL Performer class used in a pfMesh to store information about vertices. A pfMeshVertex stores the following:

This section describes these items in the following subsections:

typedef struct 
{
    int vertex;
    int face;
    short int edgeType;
    short int next, prev;
} pfMeshVertexNeighbor;

The function pfSubdivSurface() creates and returns a handle to a pfSubdivSurface. Like other pfNodes, pfSubdivSurfaces are always allocated from shared memory and cannot be created statically on the stack or in arrays. Use the function pfDelete() rather than the delete operator to delete pfSubdivSurfaces.

To define a subdivision surface, you must specify its control mesh using the function pfSubdivSurfaceMesh(). The mesh is stored as a pfMesh. A pfMesh is a data structure that stores the connectivity between individual faces of the mesh. For each vertex and face, you can access neighboring vertices and faces, respectively. See the preceding section “Meshes” for more details.

To create a pfMesh, you can either specify its faces and the connectivity one by one or use the function pfdAddNodeToMesh(). This function takes a pfNode, parses all its pfGeoSets, splits all primitives into planar faces, and adds those faces into the specified pfMesh (see the pfdAddNodeToMesh man page).

Before you set the mesh using pfSubdivSurfaceMesh(), you need to set various parameters of the subdivision because different internal data structures may be needed for different types of subdivision. You use the function pfSubdivSurfaceVal() to set the values and the function pfSubdivSurfaceFlags() to set the flags.

You can set the following values:

You can set the following flags to 0 or 1:

The following examples set up a subdivision surface and add it into a scene.

Example 1:

pfSubdivSurface *subdivSurface;
pfMesh          *mesh;

subdSurf = pfNewSubdivSurface(arena);
mesh = pfNewMesh(arena);
if(method == PFSB_LOOP)
    pfMeshFlags(mesh, PFM_FLAG_TRIANGULATE, 1); // important!

pfdAddNodeToMesh(root, mesh, 0); // part 0

pfSubdivSurfaceVal(subdSurf, PFSB_SUBDIVISION_LEVEL, subdivLevel);
pfSubdivSurfaceVal(subdSurf, PFSB_SUBDIVISION_METHOD, method);
pfSubdivSurfaceFlags(subdSurf, PFSB_GPU_SUBDIVISION, GPUsubdivision); 

Example 2:

pfSubdivSurfaceMesh(subdSurf, mesh); 
pfAddChild(scene, subdSurf);

pfSubdivSurface *subdivSurface = new pfSubdivSurface;

pfMesh *mesh = new pfMesh;
if(method == PFSB_LOOP)
    mesh->setFlags(PFM_FLAG_TRIANGULATE, 1); // important!

pfdAddNodeToMesh(root, mesh, 0); // part 0

subdivSurface->setVal(PFSB_SUBDIVISION_LEVEL, subdivLevel);
subdivSurface->setVal(PFSB_SUBDIVISION_METHOD, method); 
subdivSurface->setFlags(PFSB_GPU_SUBDIVISION, GPUsubdivision); 

subdivSurface->setMesh(mesh);

scene->addChild(subdivSurface);

You can find sample code in the file perf/samples/pguide/libpf/C++/subdivSurface.C. or in the file %PFROOT%\Src\pguide\libpf\C++\subdivSurface.cxx on Microsoft Windows.

The major difference between Loop subdivision and Catmull-Clark subdivision is in the type of faces they process. Loop subdivision operates exclusively on triangles. Therefore, the control mesh has to be triangulated. Since a pfMesh does not know whether it is used in a pfSubdivSurface and what subdivision method is used, you must set the flag PFM_FLAG_TRIANGULATE on the pfMesh before specifying the faces (see the sample code in the preceding section “Creating a Subdivision Surface”).

Catmull-Clark subdivision, on the other hand, operates on quads. If the control mesh contains non-quads, the first subdivision step is performed using special rules so that an arbitrary face is divided into a set of quads. Note that this step cannot be performed on a GPU. This step introduces some discontinuities in the second derivative of the curvature. Consequently, the surface may appear more bumpy around the edges of the original control faces. For this reason, start with a control mesh containing only quads for optimal results. The advantage of Catmull-Clark subdivision is that it is supported by many modeling tools, including Maya.

If the flag PFSB_CONTROL_VERTICES_DYNAMIC is set, you can modify the position of vertices of the control mesh to animate the surface. You need to call the function pfSubdivSurfaceUpdateControlMesh() at each frame to confirm the changes. Note that you cannot have in the node any tranforms specifying the control mesh.

You can subdivide an arbitrary file loaded into OpenGL Performer by using the libpfsubdiv pseudo loader. It works similarly as the libpftrans or libpfscale pseudo loader. Suppose that you want to subdivide truck.pfb in Perfly. You enter the following command:

perfly truck.pfb.0,2,0.subdiv

The syntax of the libpfsubdiv loader is as follows:

<filename>.<method>,<subdivLevel>,<GPUon>.subdiv

The value for method is 0 for Catmull-Clark and 1 for Loop subdivision. The subdivLevel value is usually around 2 and GPUon is 1 if the evaluation should be done fully on a GPU.

Note the following limitations and anomalies regarding the use of subdivision surfaces: