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 val-
       ues 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 winding
                      number is the same for all points in a sin-
                      gle region.


                      "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  separat-
                      ing  the  polygon interior and exterior are
                      returned instead of a  tessellation.  Exte-
                      rior contours are oriented CCW with respect
                      to the normal; interior contours  are  ori-
                      ented    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 fea-
                      ture takes part  in  several  merge  opera-
                      tions,  the  total  distance moved could be
                      larger.

                      Feature merging is completely optional; the
                      tolerance  is only a hint.  The implementa-
                      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 ver-
                      tex  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  end-
                      points are identical.


SEE ALSO

       gluGetTessProperty, gluNewTess



                                                                1