This manual page is for Mac OS X version 10.6.3

Reading manual pages

GLUTESSPROPERTY(3G)                                                                      GLUTESSPROPERTY(3G)



NAME
       gluTessProperty - set a tessellation object property


C SPECIFICATION
       void gluTessProperty( GLUtesselator* tess,
                             GLenum which,
                             GLdouble data )


PARAMETERS
       tess   Specifies the tessellation object (created with gluNewTess).

       which  Specifies    the    property    to   be   set.   Valid   values   are   GLU_TESS_WINDING_RULE,
              GLU_TESS_BOUNDARY_ONLY, GLU_TESS_TOLERANCE.

       data   Specifies the value of the indicated property.

DESCRIPTION
       gluTessProperty is used to control properties stored  in  a  tessellation  object.  These  properties
       affect  the  way  that  the polygons are interpreted and rendered.  The legal values for which are as
       follows:

       GLU_TESS_WINDING_RULE
                      Determines which parts of the polygon are on the "interior".  data may be set  to  one
                      of   GLU_TESS_WINDING_ODD,   GLU_TESS_WINDING_NONZERO,  GLU_TESS_WINDING_POSITIVE,  or
                      GLU_TESS_WINDING_NEGATIVE, or GLU_TESS_WINDING_ABS_GEQ_TWO.

                      To understand how the winding rule works, consider that the input  contours  partition
                      the  plane into regions. The winding rule determines which of these regions are inside
                      the polygon.

                      For a single contour C, the winding number of a point x is simply the signed number of
                      revolutions  we make around x as we travel once around C (where CCW is positive). When
                      there are several contours, the individual winding numbers are summed. This  procedure
                      associates  a signed integer value with each point x in the plane. Note that the wind-ing winding
                      ing number is the same for all points in a single region.

                      The winding rule classifies a region as "inside" if its winding number belongs to  the
                      chosen category (odd, nonzero, positive, negative, or absolute value of at least two).
                      The previous GLU tessellator (prior to GLU 1.2) used the  "odd"  rule.  The  "nonzero"
                      rule  is  another  common way to define the interior. The other three rules are useful
                      for polygon CSG operations.

       GLU_TESS_BOUNDARY_ONLY
                      Is a boolean value ("value" should be  set  to  GL_TRUE  or  GL_FALSE).  When  set  to
                      GL_TRUE,  a  set  of  closed contours separating the polygon interior and exterior are
                      returned instead of a tessellation. Exterior contours are oriented CCW with respect to
                      the   normal;   interior   contours   are   oriented   CW.   The   GLU_TESS_BEGIN  and
                      GLU_TESS_BEGIN_DATA callbacks use the type GL_LINE_LOOP for each contour.

       GLU_TESS_TOLERANCE
                      Specifies a tolerance for merging features to reduce the  size  of  the  output.   For
                      example,  two vertices that are very close to each other might be replaced by a single
                      vertex. The tolerance is multiplied by the largest coordinate magnitude of  any  input
                      vertex; this specifies the maximum distance that any feature can move as the result of
                      a single merge operation. If a single feature takes part in several merge  operations,
                      the total distance moved could be larger.

                      Feature merging is completely optional; the tolerance is only a hint.  The implementa-tion implementation
                      tion is free to merge in some cases and not in others, or to never merge  features  at
                      all. The initial tolerance is 0.

                      The  current  implementation  merges  vertices  only  if  they are exactly coincident,
                      regardless of the current tolerance. A vertex is spliced into  an  edge  only  if  the
                      implementation is unable to distinguish which side of the edge the vertex lies on. Two
                      edges are merged only when both endpoints are identical.

SEE ALSO
       gluGetTessProperty(3G), gluNewTess(3G)




                                                                                         GLUTESSPROPERTY(3G)