Element type: |
- |

Data type: |
miApprox |

Sizes: |
- |

Defaults: |
as set by miAPPROX_DEFAULT() |

enum miApprox_method { miAPPROX_PARAMETRIC, miAPPROX_REGULAR, miAPPROX_SPATIAL, miAPPROX_CURVATURE, miAPPROX_LDA, miAPPROX_ADJACENCY, /* only for curves */ miAPPROX_ALGEBRAIC, /* only for surfaces */ miAPPROX_DEFTRIM, /* only for miFace def_trim_approx */ miAPPROX_REGULAR_PERCENT, /* new in 3.2, regular param n% m% */ miAPPROX_INDIRECT, miAPPROX_NMETHODS }; enum miApprox_style { miAPPROX_STYLE_NONE, miAPPROX_STYLE_GRID, miAPPROX_STYLE_TREE, miAPPROX_STYLE_DELAUNAY, miAPPROX_STYLE_FINE, /* sub-object/subpixel tessellation */ miAPPROX_STYLE_FINE_NO_SMOOTHING,/* fine poly displacement without Hermite interpolation */ miAPPROX_NSTYLES }; #define miCNST_UPARAM 0 /* regular/parametric only */ #define miCNST_VPARAM 1 #define miCNST_LENGTH 0 /* curvature/spatial only */ #define miCNST_DISTANCE 1 #define miCNST_ANGLE 2 enum miCnst_type { miCNST_VISIBLE = 0, /* for accessing (int)cnst[0] */ miCNST_TRACE, miCNST_SHADOW, miCNST_CAUSTIC, miCNST_GLOBILLUM, miCNST_NTYPES /* must not be > 7 ! */ }; typedef struct miApprox { miScalar cnst[6]; /* indexed with miUPARAM...miANGLE */ miUint1 sharp; /* 0=smooth normals, 255=faceted */ miCBoolean spare; /* not used */ miCBoolean any; /* stop if any criterion is met */ miCBoolean view_dep; /* view dependent? */ enum miApprox_method method; enum miApprox_style style; miUshort subdiv[2]; /* recursive subdivision depth */ miGeoIndex max; /* maximum number of triangles */ miScalar grading; /* min angle bound for graded meshing*/ } miApprox; #define miAPPROX_MAX_SUBDIV 7 #define miAPPROX_DEFAULT(A) do { \ (A).style = miAPPROX_STYLE_TREE; \ (A).method = miAPPROX_PARAMETRIC; \ (A).sharp = 0; \ (A).flag = miAPPROX_FLAG_ANY; \ (A).any = miFALSE; \ (A).view_dep = miFALSE; \ (A).cnst[0] = 0.0; \ (A).cnst[1] = 0.0; \ (A).cnst[2] = 0.0; \ (A).cnst[3] = 0.0; \ (A).cnst[4] = 0.0; \ (A).cnst[5] = 0.0; \ (A).subdiv[miMIN] = 0; \ (A).subdiv[miMAX] = 5; \ (A).max = miHUGE_INT; \ (A).grading = 0.0; } while (0) #define miAPPROX_FINE_DEFAULT(A) do { \ (A).style = miAPPROX_STYLE_FINE; \ (A).method = miAPPROX_LDA; \ (A).sharp = 0; \ (A).flag = (1<<miCNST_NTYPES)-1;\ (A).any = miFALSE; \ (A).view_dep = miTRUE; \ (A).cnst[0] = 0.25; \ (A).cnst[1] = 0.0; \ (A).cnst[2] = 0.0; \ (A).cnst[3] = 0.0; \ (A).cnst[4] = 0.0; \ (A).cnst[5] = 0.0; \ (A).subdiv[miMIN] = 0; \ (A).subdiv[miMAX] = miAPPROX_MAX_SUBDIV; \ (A).max = miHUGE_INT; \ (A).grading = 0.0; } while (0)

A translator may provide: all fields.

The approximation structure is a substructure of
**miPolygon_list**, **miCurve**, and **miSurface**. It
does not have its own database entry and no associated SCENE
functions of its own.

**method** is the approximation method, and must be one of
`miAPPROX_PARAMETRIC`, `miAPPROX_REGULAR`,
`miAPPROX_SPATIAL`, `miAPPROX_CURVATURE`,
`miAPPROX_LDA`, `miAPPROX_ADJACENCY` (available for
curves only), and `miAPPROX_REGULAR_PERCENT`. The default is
`miAPPROX_PARAMETRIC`. "LDA" stands for Length, Distance,
Angle; this mode combines the spatial and curvature-dependent modes
which are now considered obsolete. As a special case, the value of
`miAPPROX_INDIRECT` switches the meaning of the cnst array
to an array of six integer offsets into the inherited approximation
list, which contains up to ten approximations separately for
visible, trace, shadow, and other flagged approximations.

**tyle** is the approximation style, and must be one of
`miAPPROX_NONE`, `miAPPROX_GRID`,
`miAPPROX_TREE`, `miAPPROX_STYLE_FINE`^{3.1},
and `miAPPROX_STYLE_FINE_NO_SMOOTHING`^{3.4}\. Tree
mode is the default. The API and GAP module will automatically
change the style field to grid mode if the method is parametric or
regular. The fine approximation
style^{3.1} only works with parametric and edge length
criteria; the recommended mode is view-dependent edge length with a
subpixel diagonal constant. If any approximation in an object uses
fine approximation, the miObject
should have the `fine` flag set. fine approximation, no
smoothing can be used for polygon displacement for turning off a
smoothing procedure which is used by default during fine polygon
displacement. (See page fineapprox
for more details about fine
approximation.)

**sharp**^{3.1} controls the normal vector
interpolation. If set to 0, mental ray uses the interpolated normal
as specified by the base surface, modified by displacement if
available. If set to 255 (which corresponds to 1.0 in the .mi scene
file), mental ray will use the geometric normal for a faceted look.
This is primarily useful in
`miAPPROX_STYLE_FINE`^{3.1} mode. mental ray 3.2
also accepts values in the range 1..254 to blend smoothly between
interpolated and faceted tessellations.

**any**, if `miTRUE`, makes the tessellation stop if
*any* criterion is met, instead of when *all* criteria
are met. Close faces are tessellated more finely than distant
faces. This mode is not available for the parametric and regular
method.

**view_dep**, if `miTRUE`, turns on view-dependent
tessellation. Close faces are tessellated more finely than distant
faces. This mode is not available for the parametric and regular
method.

**cnst[0]**, **cnst[1]**, and **cnst[2]** specify the
approximation precision. They depend on the approximation method.
The defaults are 1.0 (which is not ideal for curvature-dependent
tessellation). The **cnst** array should be indexed using the
`miCNST_`* constants. The cnst array was a
`miGeoScalar` array up to mental ray 3.1, and switch to
`miScalar` in mental ray 3.2. If the method field is
`miAPPROX_INDIRECT`, these six cnst fields are interpreted
as integer offsets into the inherited approximation list, which
contains the actual approximations to use. Indirection cannot be
nested. For example, if the method is indirect, the approximation
to use for shadow rays is `inheritedlist [ (int)approx.cnst [
miCNST_SHADOW ]]`.

**subdiv** specifies the minimum and maximum number of
subdivision recursion levels.

**grading** is used for Delaunay tessellation only, and
specifies how gradually the triangle mesh should become finer.

technique | cnst[0] |
cnst[1] |
cnst[2] |
---|---|---|---|

parametric | (number of U subdivs) ⁄ degree | (number of V subdivs) ⁄ degree | - |

regular | number of U subdivs | number of V subdivs | - |

spatial | edge length limit | - | - |

curvature | - | distance tolerance | angle tolerance |

lda | edge length limit | distance tolerance | angle tolerance |

**subdiv[0]** and **subdiv[1]** specify the recursion
limits. The defaults are 0 and 5, respectively. The maximum value
is 7. A subdivision level *n* means that the curve, triangle,
or surface is halved in each parameter direction *n* times,
yielding on the order of *2^n* segments. The limits have no
effect on Delaunay triangulation.

**max** is used only for Delaunay triangulation. It specifies
the maximum number of triangles to create. The number may be
exceeded if the trimming and hole curves have too many
vertices.

Copyright © 1986, 2013 NVIDIA Corporation