Free-form surfaces are polynomial patches of any degree up to twenty-one. [11] Supported basis types include Bézier, Taylor, B-spline, cardinal, and basis-matrix form. Any type can be rational or non-rational. Patches can be explicitly or automatically connected to one another, or may be defined to contain explicitly defined points or curves in their approximation. Various approximation types including (regular) parametric, spatial, curvature-dependent, view-dependent, and combinations of these, as well as fine approximation, which can generate microtriangle tessellations very efficiently. Surfaces may be bounded by a trimming curve, and may contain holes.

Surface geometry, like polygonal geometry, is defined by a series of sections. An object containing only surface geometry follows this broad outline:

object "object_name" [ visible [on|off] ] [ shadow [on|off] ] [ shadowmap [on|off] ] [ trace [on|off] ] [ reflection [mode] ] [ refraction [mode] ] [ transparency [mode] ] [ select [on|off] ] [ tagged [on|off] ] [ caustic [on|off] ] [ globillum [ on|off ] ] [ face [front|back|both] ] [ caustic [mode] ] [ globillum [mode] ] [ box [min] ] [ motion box [_{x}min_{y}min_{z}max_{x}max_{y}max_{z}min] ] [ max displace_{x}min_{y}min_{z}max_{x}max_{y}max_{z}value] [ samplesmin max] [ data null|"data_name" ] [ taglabel_number_{int}] [basis_list] groupvector_listvertex_list[list of curves]surface[list of surface derivative requests] [list of texture or vector surfaces] ... # more surfaces [list of approximation statements] [list of connection statements] end group end object

Curves, surfaces, approximations, and connections may be interspersed as long as names are defined before they are used. For example, a curve must come before the surface it is trimming, and an approximation must come after the surface to be approximated. Texture and vector texture surfaces must always directly follow the surface they apply to. The individual sections are:

- The
*basis_list*must be specified at the beginning of the object definition, just before the group begins. Bases defined in this section are referenced by name in the curve and surface definitions to specify their degrees and types (Bézier, B-spline, etc.). - The
*vector_list*in the group is a list of (x , y , z) vectors used to build control points later. This section is the same as the vector section used to build vertices for polygonal geometry. - The
*vertex_list*that follows the vector list builds control points out of the vectors. This also works like the vertex list for polygonal geometry, except that no normals and texture vertices can be defined here (no`n`,`t`,`d`, or`u`statements may appear). Normals are defined implicitly by the surface, and textures are defined by*texture surfaces*instead as described below. Surface derivatives are generated if`derivative`keywords are present. Rational curves and surfaces specify additional weights at each vertex reference (see below). *Curves*may be defined and used as trimming curves, hole curves, and special curves. This section is optional; if no trimming curve is defined surfaces are untrimmed and end at the boundaries specified by the ranges of the bases used. Trimming a surface means to cut away portions that fall outside an outer boundary curve; holes cut away portions inside the hole curve. Special curves are curves that are always included in the tessellation; they can be used to define features like sharp creases that need to be tessellated consistently. Surfaces may also be connected along trimming curves.- The surface geometry list consists of
`surface`statements, much like polygonal geometry that consists of`p`and`c`statements. A surface is defined by a`surface`statement, optionally followed by surface derivative request statements and one or more`texture surface`or`vector surface`statements. *Approximation*statements give additional information about how a surface and its trimming, hole, and special curves are to be approximated with triangles. Various modes such as parametric, regular parametric, curvature-dependent, and view-dependent approximations can be selected, along with the precision. If there are approximation statements in the`options`statement (see Options, Tessellation Quality above), they override any approximation statements in the objects.

For a description of vector lists and vertex lists, refer to page vector.

When surfaces and curves are present within an object group, it is mandatory that at
least one basis has been defined
within the object. Bases define the degree and type of polynomials
(denoted by N_{i,n} below) to be
used in the description of curves or surfaces. Curves and surfaces
reference bases by name. Every surface needs two bases, one for the
U and one for the V parameter direction. Both can have a different
degree, but must have the same type (for example, rational
Bézier in U and Cardinal in V is not allowed). There are
five basis types:

basis "basis_name" [ rational ] taylordegree_{int}basis "basis_name" [ rational ] bezierdegree_{int}basis "basis_name" [ rational ] cardinal basis "basis_name" [ rational ] bsplinedegree_{int}basis "basis_name" [ rational ] matrixdegree_{int}stepsize_{int}basis_matrix

A parametric representation may be either non-rational or
rational as indicated by the `rational` flag. Rational
curves and surfaces specify additional weights at each control
point. This flag is optional; it can also be specified in the
curves and surfaces that reference the basis.

The *degree* specifies the degree of the polynomials used
in the description of curves or surfaces. Recall that the degree of
a polynomial is the highest power of the parameter occurring in its
definition. When bases of degree 1 are used control points are
connected with straight lines. Cardinal bases always have degree 3.
The degree and the type combined determine the length of the
**parameter vector** and
the number of control points needed for the surface. The meaning of
the parameter vector differs for the different basis types. This is
described in detail below.

The supported polynomial types for curves and surfaces are
`bezier`, `bspline`, `taylor`,
`cardinal` and `matrix`.

When a curve or surface is being evaluated and a transition from
one segment or patch to the next occurs, the set of control points
(the `evaluation window') used is incremented by the
*stepsize*. The appropriate *stepsize* depends on the
representation type expressed through the basis matrix and on the
degree.

Consider a curve with *k* control points {v_{1} , … , v_{k}}. If the
curve is of degree n, then n+1 control points are needed for each polynomial
segment. If the *stepsize* is given as s, then the (1+i)th
polynomial segment will use the control points {v_{is+1} , … , v_{is+n+1}}.
For example, for Bézier curves s=n, whereas for Cardinal curves s=1. For surfaces, the above description applies
independently to each parametric dimension.

The *basis_matrix* specifies the basis functions used to
evaluate a parametric representation. For a basis of degree
n the matrix must be of size (n+1)×(n+1). The matrix is laid out in the
order b_{00} , b_{01} , …
, b_{0n} , … , b_{nn}. Note that the
generalization to the rational case for all representations is
admitted in all cases.

As an example, an object containing a nonrational Bézier surface of degree 3 in one parameter direction and degree 1 in the other parameter direction needs two bases defined at the beginning of the object like this:

object "mysurface" visible basis "bez1" bezier 1 basis "bez3" bezier 3 group ...

The surface definition will reference the two bases by their
names, `bez1` and `bez3`.

A surface specifies a name and a list of control points. For
both parametric dimensions it specifies a basis, a global **parameter range**, and a parameter list.
Optionally, it specifies surface
derivative requests, texture
surfaces, trimming curves,
hole curves, special curves and special points. Special curves and
points are included as edges and vertices in the approximation (triangulation) of the
surface.

surface "surface_name" "material_name" "u_basis_name"range u_param_list"v_basis_name"range v_param_listhom_vertex_ref_list[derivative_request] [texture_surface_list] [surface_specials_list]

If the enclosing object has the `tagged` flag set, a
label integer must be given instead of a material name (see page
tagged). This changes the first
line of the preceding syntax block to:

surface "surface_name"label_number_{int}

The bases used in the definition of the surface must have been
defined in the *basis list* of the object. They are referenced
by their *basis_name*s. Their *range*s consist of two
floating-point numbers specifying the minimum and maximum parameter
values used in the respective direction.

The *parameter_list*s in the basis
specifications define the number of patches of the surface and the
number of control points. For bases of the types `taylor`,
`bezier`, `cardinal` and `matrix` such a
*parameter_list* consists of a strictly increasing list of at
least two floating-point numbers. For `bspline` bases the
*parameter_list*s specify the knot vector. If the B-spline basis to be used is of degree
n, the knot vector ( x_{0} , … , x_{q}) must have
at least q+1=2(n+1) elements. Knot values
represent a monotone sequence of floating-point numbers but are not
necessarily strictly increasing, i.e. x_{i} ≤ x_{i+1}. Moreover, they
must satisfy the following conditions:

(1) x_{0}< x_{n+1}(2) x_{q−n−1}< x_{q}(3) x_{i}< x_{i+n}for 0 < i < q−n−1 (4) x_{n}≤ t_{min}< t_{max}≤ x_{q−n}

where [t_{min} ,
t_{max}] is the range over which the B-spline is to be evaluated. Equation
(1) demands that no more than n + 1
parameters at the beginning of the parameter list may have the same
value. Equation (2) is the same restriction for the end of the
parameter list. Equation (3) says that in the middle of the
parameter list, at most n consecutive
parameters may have the same value. To generate closed B-spline
curves, it is often necessary to write a parameter list where the
first n and last n parameters in the list produce initial and final
curve segments that should not become part of the curve; in this
case equation (4) allows choosing a start and end parameter in the
range bounded by the first and last parameter of the parameter
list.

The number of control points per direction can be derived from
the number of parameters *p*, the degree of the basis
*n*, and the step size *s*. Their total number can be
calculated by multiplying the numbers taken from the following
table for each of the U and V directions.

type | min # of parameters | # of control points |
---|---|---|

Taylor |
2 |
(p−1) · (n+1) |

Bézier |
2 |
(p−1) · n + 1 |

Cardinal |
2 |
p + 2 |

Basis matrix |
2 |
(p−2) · s + n + 1 |

B-spline |
2(n+1) |
p−n−1 |

Note that only certain numbers of control points are possible; for example, if the U basis is a degree-3 Bézier, the number of control points in the U direction can be 4, 7, 10, 13, and so on, but not 3 or 5. For B-spline bases of degree 3 the minimum number of parameters is 8 corresponding to 4 control points.

Each vertex reference in the *hom_vertex_ref_list* is an
integer index into the vertex list of the current group in the
object (index 0 is the first vertex). When the surface is rational,
**homogeneous coordinates**
must be given with the **control point**s, by appending a floating-point
weight to every vertex reference integer in the
*hom_vertex_ref_list*. There are two methods for specifying
weights: either a simple floating-point number that must contain a
decimal point to distinguish it from an integer index, or the
keyword `w` followed by a weight value that need not contain
a decimal point. The `w` keyword method is recommended
because it eliminates the requirement that numbers contain decimal
points, so translators can use `%g` format specifiers.
Weights are used only if the surface is rational and ignored
otherwise. If a weight in a rational surface is missing, it
defaults to 1.0.

The surface specials list is used to define trimming curves, hole curves, special curves, and special points (vertex references). A surface may be further modified by approximation and connection statements, as described below.

For example, an object with a simple degree-3 Bézier surface can be written as:

object "mysurface" visible basis "bez3" bezier 3 group 0.314772 -3.204608 -7.744229 # vector 0 0.314772 -2.146943 -6.932366 0.314772 -1.089277 -6.120503 0.314772 -0.031611 -5.308641 -0.660089 -2.650739 -8.465791 # vector 4 -0.660089 -1.593073 -7.653928 -0.660089 -0.535407 -6.842065 -0.660089 0.522259 -6.030203 -1.634951 -2.096869 -9.187352 # vector 8 -1.634951 -1.039203 -8.375489 -1.634951 0.018462 -7.563627 -1.634951 1.076128 -6.751764 -2.609813 -1.543000 -9.908914 # vector 12 -2.609813 -0.485334 -9.097052 -2.609813 0.572332 -8.285189 -2.609813 1.629998 -7.473326 v 0 v 1 v 2 v 3 # vertices v 4 v 5 v 6 v 7 v 8 v 9 v 10 v 11 v 12 v 13 v 14 v 15 surface "surf1" "material" "bez3" 0.0 1.0 0.0 1.0 "bez3" 0.0 1.0 0.0 1.0 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 end group end object

First, 16 vectors are defined, each of which is used to build
one vertex (control point). Next, a surface is defined that uses
basis `bez3` for both the U and V parameter directions.
Since the surface is built from only one 4 × 4 Bézier
patch, the parameter vector
after the basis range has only length 2. If there had been two
patches in the U direction and three in the V direction, the bases
would have been referenced as

"bez3" 0.0 1.0 0.0 0.5 1.0 "bez3" 0.0 1.0 0.0 0.33333 0.66667 1.0

Alternatively, the parameter vector may be given as

"bez3" 0.0 2.0 0.0 1.0 2.0 "bez3" 0.0 3.0 0.0 1.0 2.0 3.0

by changing the parameter range of the basis. This has no influence on the geometry of the surface, but generates UV texture coordinates in a different range (here, [0.0, 2.0] × [0.0, 3.0]). However, a different parameterization does affect the texture surface range (see below), and the range of trimming, hole, and special curves (which do not define their own ranges but borrow the range from the surface they apply to).

The optional *surface_specials_list* that completes the
surface definition is a sequence of trimming curves, hole curves,
special curves, and special points as described in the next
section.

mental ray can automatically generate **surface derivative** vectors if requested. First
derivatives describe the UV parametric gradient of a surface;
second derivatives describe the curvature. They are computed and
stored only if requested by *derivative_request* statements in
the surface definition:

derivativenumber_{int}[number_{int}]

There can be one or more `derivative` statements that
request first and/or second derivatives. Valid values for
*number* are 1 and 2, for first and second derivatives,
respectively.

mental ray does not use derivative vectors but makes them
available to shaders. First derivatives are presented as two
vectors (*dS du* and *dS dv*, with S being the surface
and the derivatives evaluated at the current point in parameter
space); second derivatives are presented as three vectors (
*d ^{2}S du^{2}*,

A plain `surface` statement defines the geometry of the
surface. If a texture is to be mapped on the surface, it is
necessary to include texture
surfaces. A texture surface defines a mapping from raw UV
coordinates to texture
coordinates as used by shaders. A vector texture is a variation
of a texture surface that additionally defines a pair of basis
vectors; it is used for bump
mapping.

The texture or vector texture directly following a surface
defines texture space number 0,
the next defines texture space number 1, and so on, exactly like
the first `t` statement after the `v` statement in a
vertex used for building polygonal geometry defines texture space
number 0, the next `t` defines texture space number 1, and
so on. Basically, texture and vector texture surfaces replace the
`t` statements used by polygonal geometry, because attaching
textures to control points that usually are not part of the surface
is not useful.

Texture spaces is what ends up in the
`state→tex_list`

array where it can be accessed by
texture shaders to decide which texture is mapped which way.
Texture space 0 is the first entry in that array, which is used by
the shader for the first texture listed in the texture list in the
material definition. In general, there is one texture space per
texture on a material, although shaders making nonstandard use of
texture spaces could be written.

The syntax for texture surfaces is a simplified version of
geometric surfaces. The *texture_surface_list* in the grammar
summary at the beginning of the "Surfaces" section above expands to
zero or more copies of the following block:

[ volume ] [ vector ] texture "u_basis_name"u_param_list"v_basis_name"v_param_listvertex_ref_list

Unlike geometric surfaces, no surface name and material name is
given. Bases are given like in geometric surfaces. Texture surfaces
use the ranges of the geometric surface they are attached to, they
are not repeated in the texture surface basis statements. The
*vertex_ref_list* follows the same rules as the geometric
surface's *vertex_ref_list*. Texture surfaces have no specials
such as trimming curves or holes.

The optional `volume` keyword in the texture surface
definition disables seam compensation. It should be used for 3D
textures where each texture vector should be used verbatim. If the
`volume` flag is missing, the tessellator detects textures
that span the geometric seam on closed surfaces, and prevents
rewinding. Consider a sphere with a 2D texture that is shifted
slightly in the U parameter direction: a triangle might have
u_{0} = 0.0 on one side and
u_{1} = 0.1 on the other side. If
the texture is shifted towards higher u
coordinates by *0.05*, u_{0}
and u_{1} will map to texture coordinates t_{0} = 0.95 and t_{1} = 0.05, assuming an otherwise normal UV
mapping. Even though u_{0} <
u_{1}, t_{0} >>
t_{1}, causing a fast "rewind" of the texture. Seam
compensation corrects t_{1} to
*1.05*. This is undesirable for 3D textures, which should have
the `volume` keyword set. Most problems with strangely
shifted textures are caused by inappropriately used or missing
`volume` keywords.

The optional `vector` keyword in the texture surface
definition is a flag that causes **bump basis vectors** to be calculated during
tessellation. This flag must be used if the texture surface is used
for a bump map that expects to find bump basis vectors in the
geometry. However, this is not a frequently used requirement - the
standard mental ray shaders don't depend on them, for example.

This is an example for the simplest of all texture surfaces, a bilinear mapping:

object "mysurface" visible basis "bez1" bezier 1 basis "bez3" bezier 3 group # ... 16 vectors used for the surface 0.0 0.0 0.0 # vector number 16 0.0 1.0 0.0 # vector number 17 1.0 0.0 0.0 # vector number 18 1.0 1.0 0.0 # vector number 19 # ... 16 vertices used for the surface v 16 # vertex number 16 v 17 # vertex number 17 v 18 # vertex number 18 v 19 # vertex number 19 surface "surf1" "material" "bez3" 0.0 1.0 0.0 1.0 "bez3" 0.0 1.0 0.0 1.0 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 texture "bez1" 0.0 1.0 "bez1" 0.0 1.0 16 17 18 19 end group end object

This texture surface defines a bilinear mapping from the UV
coordinates computed during surface tessellation to the texture coordinates. To define other
than bilinear mappings, the texture surface needs to have more
control points than just one at every corner of the surface.
Whenever the surface tessellator generates a triangle vertex, it
uses the UV coordinate of that vertex to look up the texture
surface and interpolate the texture
coordinate from the nearest four points of the texture surface.
The resulting texture
coordinate is stored with the vertex and becomes available in
`state→tex_list`

when the material shader is called
because a ray has hit the surface.

If more than one texture surface is given, one texture coordinate is computed for each
texture surface and stored in sequence in the generated triangle
vertices. Each texture surface is said to define a "**texture space**". They are
available in the `state→tex_list`

array in the same
order. The number and order of texture surfaces should agree with
the number and order of textures given in the texture list in the
material definition. (Note that not all material shaders support
multiple textures.)

If the material name of a surface is empty (two consecutive double quotes), the surface uses the material from the closest instance (this is called material inheritance).

Curves are two-dimensional parametric curves when they are referenced by surfaces. They are used as trimming curves, hole curves, and special curves. They must be defined before the surface which references them. Curves are three-dimensional parametric curves when referenced by space curves. A curve is defined as:

curve "curve_name" "basis_name"parameter_listhom_vertex_ref_list[ specialspecial_point_list]

The *parameter_list* of a curve is a list of monotonically
increasing floating-point numbers that define the number of
segments of the curve and the number of control points. Curve
parameter lists work very much the same way as surface parameter
lists except that no range needs to be provided, because they are
supplied by the surfaces that reference the curve under
consideration as explained in the next section. For details on
parameter lists, see the sections on bases and surfaces above.

Each vertex reference in the *hom_vertex_ref_list* is an
integer index into the vertex list of the current group in the
object (index 0 is the first vertex), optionally followed by the
keyword `w` and a weight value. (For backwards
compatibility, the `w` keyword may be omitted if the weight
is a floating-point value containing a decimal point.) Weights are
used only if the curve is rational, they are ignored otherwise. If
a weight in a rational curve is missing, it defaults to 1.0. The
vertices indexed by the integers in the *hom_vertex_ref_list*
should have no normals or textures (no `n` and `t`
statements), and the third component of the vector ( `v`
statement) should be *0.0* because curves are defined in UV
space, not 3D space.

The optional
*special_point_list* specifies points that are included in the
approximation of the curve. After the `special` keyword, a
sequence of integers follows that index into the vertex list, just
like the integers in the *hom_vertex_ref_list*. The first
component of the vector is used as the *t* parameter; it
forces the point on the curve at parameter value *t* to become
part of the curve approximation. Of course *t* must be in the
range of parameters allowed by the surface definition.

A surface may reference curves to trim the surface, to cut holes
into it, and to specify "**special curve**s" that become part of the
tessellation of the surface. Special points in surfaces work like
special points in curves, except that they provide a point in the
parameter range of the surface, that is, a two-dimensional UV
coordinate, rather than a one-dimensional curve parameter. They
specify single points on the surface that are to be included in the
tessellation. As all curves and points are in UV space, the third
component of the vectors provided for them is ignored. None of the
above types of curves and points may exceed the range of *(0.0,
1.0)* at any point.

No two curves may intersect each other, and no curve may self-intersect. This is an important point because trimming curves and holes that are not closing or intersecting themselves or other loops can produce unexpected tessellation results.

Trimming, hole, and special curves and special points are
defined at the end of the surface definition. The curves are
composed of segments from the list of curves of the surface's
group. The *surface_specials_list* given in the previous
section is a list of zero or more of the following four items:

trim "curve_name"min max... hole "curve_name"min max... special "curve_name"min max... specialvertex_{int}...

The dots indicate that each trim, hole, and special statement may be followed by more than one curve segment or vertex, respectively. All listed segments are concatenated to form a single curve.

The *vertex* integers specify vertices from the vertex
section of the current group in the current object. Such a vertex
specifies the UV coordinate of the special point that is to be
included in the tessellation.

Each of the three types of curves references a curve that has
been defined earlier with a `curve` statement. If a single
`trim`, `hole`, or `special` statement is
followed by more than one curve, the resulting trimming, hole, or
special curve is pieced together by concatenating the given curves.
The *min* and *max* parameters allow using only part of
the curve referenced. *min* and *max* must be in the
range of the parameter vector of the curve which in turn must be
mapped into the parameter range
of the surface. The *min* and *max* parameters of two
different curve pieces are independent, they only depend on the
curve parameter lists. For example, a trimming curve can be built
from two curves, using the first three quarters of the first curve
and the last three quarters of the second curve:

curve "trim1" "bez1" 0.0 1.0 2.0 3.0 4.0 0 1 2 3 4 curve "trim2" "bez1" 0.0 1.0 2.0 3 5 0 surface "patch1" "mtl" "bez3" 0.0 1.0 0.0 1.0 "bez3" 0.0 1.0 0.0 1.0 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 trim "trim1" 0.0 3.0 "trim2" 0.5 2.0

Both trimming curves use the
basis `bez1`, which is assumed to be a degree-1 linear
curve. Hence, `trim1` connects the UV vertices 0, 1, 2, 3,
and 4 with straight lines, and `trim2` connects the vertices
3, 5, and 0. If these two curves are put together by the
`trim` statement in the surface definition, all parts of the
surface that fall outside the polygon formed by the UV vertices 0,
1, 2, 3, and 5 are trimmed off. The `trim2` curve includes
vertex 0 to close the trimming curve. Holes and special curves are constructed exactly
the same way. Trimming curves and holes must form closed loops but
special curves are not restricted in this way.

Note that trimming and hole curves must be listed in the correct order, outside in. If there is an outer trimming curve, it must be listed first, followed by the holes. If a hole has a hole, the inner hole must be listed after the outer hole. Since curves may never intersect, there is always an unambiguous order - if a curve A encloses curve B, A must be listed before B. Curves that do not enclose one another can be listed in any order.

This example omits the vector and vertex parts of the group in the object. Here is an example that defines a complete object containing a surface with a trimming curve that precisely follows the outer boundary. A trimming curve that follows the outer surface boundary does not actually clip off any part of the surface, but it is still useful if surfaces are to be connected, because connections work on trimming curves.

object "mysurface" visible basis "bez1" bezier 1 basis "bez3" bezier 3 group # ... 16 vectors used for the surface 0.0 0.0 0.0 # vector number 16 1.0 0.0 0.0 # vector number 17 1.0 1.0 0.0 # vector number 18 0.0 1.0 0.0 # vector number 19 # ... 16 vertices used for the surface v 16 # vertex number 16 v 17 # vertex number 17 v 18 # vertex number 18 v 19 # vertex number 19 curve "trim1" "bez1" 0.0 0.25 0.5 0.75 1.0 16 17 18 19 16 surface "surf1" "material" ... trim "trim1" 0.0 1.0 end group end object

The trimming curve in the example is linear, using a degree-1 Bézier basis. This means that the parameter vector has five equally-spaced parameters, one for each corner in counter-clockwise order and back to the first corner to close the trimming curve. Trimming and holes always require a closed curve or sequence of curves (they can be pieced together by multiple curves as long as the pieces form a closed loop together). The results are undefined if trimming or hole loops are not closed, or intersect.

If the trimming curve would be a degree-3 Bézier going
through four corner points, a parameter vector with 3·5+1=16 parameters would be required (again,
the *5* is the number of corners visited including the return
to the first to close the curve).

For details on the parameter vector following the basis name in the definition of the curve, refer to section curve. The bases and parameter vectors for curves and surfaces follow the same rules, except that curves have no explicit range; they always use the implicit range given by the parameter list.

Free-form
surfaces may be connected to each other using the `connect`
statements, respectively.

The `connect` statement is "manual" in that it requires
an explicit specification of the parts of two surfaces to be
connected. These parts refer to intervals of *trimming curves*
or *hole curves* of these surfaces, see section curve. A *connection* is defined
as:

connect "surface_name" "_{1}curve_name"_{1}min"_{1}max_{1}surface_name" "_{2}curve_name"_{2}min_{2}max_{2}

This statement closes the gap between two surfaces
*surface_name _{1}* and

- As always, the trimming curve or sequence of trimming curves must be closed.
- It does not matter whether the trimming curve is oriented clockwise or counterclockwise, but if a sequence of trimming curves is used all pieces must have the same direction.
- The trimming curves along the connected range must run in the same direction in 3D space.

The range values *min _{1,2}* and

Best results are obtained if the curves to be connected are
close to each other in world space and have at least approximately
the same length. The `connect` statement is not meant to be
a replacement for proper modeling. For carefully modeled surfaces
these techniues will not be necessary most of the time. Their
purpose is to close small cracks between adjacent surfaces that are
already not too far from each other. Topologically complex
situations with several connections meeting in a point are beyond
its scope.

[11] The algorithms used impose no inherent limit. The limit may be increased in future versions.

Copyright © 1986-2010 by mental images GmbH